storj/pkg/piecestore/pstore_test.go

// Copyright (C) 2018 Storj Labs, Inc.
// See LICENSE for copying information.

package pstore

import (
	"os"
	"path"
	"path/filepath"
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestStore(t *testing.T) {
  tests := []struct{
		it string
		id string
		content []byte
		expectedContent []byte
    err string
  } {
	    {
				it: "should successfully store data",
				id: "0123456789ABCDEFGHIJ",
				content: []byte("butts"),
				expectedContent: []byte("butts"),
	      err: "",
	    },
			{
				it: "should return an error when given an invalid id",
				id: "012",
				content: []byte("butts"),
				expectedContent: []byte("butts"),
				err: "argError: Invalid id length",
			},
	 }

  for _, tt := range tests {
		t.Run(tt.it, func(t *testing.T) {
			assert := assert.New(t)
			storeFile, err := StoreWriter(tt.id, os.TempDir())
			if tt.err != "" {
				if assert.NotNil(err) {
					assert.Equal(tt.err, err.Error())
				}
				return
			} else if err != nil {
				t.Errorf("Error: %s", err.Error())
				return
			}

			// Write chunk received to disk
			_, err = storeFile.Write(tt.content)
			assert.Nil(err)

			storeFile.Close()

			folder1 := string(tt.id[0:2])
			folder2 := string(tt.id[2:4])
			fileName := string(tt.id[4:])

			createdFilePath := path.Join(os.TempDir(), folder1, folder2, fileName)

			createdFile, err := os.Open(createdFilePath)
			if err != nil {
				t.Errorf("Error: %s opening created file %s", err.Error(), createdFilePath)
				return
			}
			buffer := make([]byte, int64(len(tt.content)))
			createdFile.Seek(0, 0)
			_, _ = createdFile.Read(buffer)

			createdFile.Close()
			os.RemoveAll(path.Join(os.TempDir(), folder1))

			if string(buffer) != string(tt.expectedContent) {
				t.Errorf("Expected data butts does not equal Actual data %s", string(buffer))
				return
			}
		})
  }
}

func TestRetrieve(t *testing.T) {
  tests := []struct{
		it string
		id string
		size int64
		offset int64
		content []byte
		expectedContent []byte
    err string
  } {
	    {
				it: "should successfully retrieve data",
				id: "0123456789ABCDEFGHIJ",
				size: 5,
				offset: 0,
				content: []byte("butts"),
				expectedContent: []byte("butts"),
	      err: "",
	    },
			{
				it: "should successfully retrieve data by offset",
				id: "0123456789ABCDEFGHIJ",
				size: 5,
				offset: 5,
				content: []byte("butts"),
				expectedContent: []byte("butts"),
	      err: "",
	    },
			{
				it: "should successfully retrieve data by chunk",
				id: "0123456789ABCDEFGHIJ",
				size: 2,
				offset: 5,
				content: []byte("bu"),
				expectedContent: []byte("bu"),
	      err: "",
	    },
			{
				it: "should return an error when given negative offset",
				id: "0123456789ABCDEFGHIJ",
				size: 0,
				offset: -1337,
				content: []byte("butts"),
				expectedContent: []byte(""),
	      err: "argError: Invalid offset: -1337",
	    },
			{
				it: "should successfully retrieve data with negative length",
				id: "0123456789ABCDEFGHIJ",
				size: -1,
				offset: 0,
				content: []byte("butts"),
				expectedContent: []byte("butts"),
	      err: "",
	    },
	 }

  for _, tt := range tests {
		t.Run(tt.it, func(t *testing.T) {
			assert := assert.New(t)

			folder1 := string(tt.id[0:2])
			folder2 := string(tt.id[2:4])
			fileName := string(tt.id[4:])

			createdFilePath := path.Join(os.TempDir(), folder1, folder2, fileName)

			if err := os.MkdirAll(filepath.Dir(createdFilePath), 0700); err != nil {
				t.Errorf("Error: %s when creating dir", err.Error())
				return
			}

			createdFile, err := os.OpenFile(createdFilePath, os.O_RDWR|os.O_CREATE, 0755)
			if err != nil {
				t.Errorf("Error: %s opening created file %s", err.Error(), createdFilePath)
				return
			}

			createdFile.Seek(tt.offset, 0)
			_, err = createdFile.Write(tt.content)
			if err != nil {
				t.Errorf("Error: %s writing to created file", err.Error())
				return
			}
			createdFile.Close()

			storeFile, err := RetrieveReader(tt.id, tt.offset, tt.size, os.TempDir())
			if tt.err != "" {
				if assert.NotNil(err) {
					assert.Equal(tt.err, err.Error())
				}
				return
			} else if err != nil {
				t.Errorf("Error: %s", err.Error())
				return
			}

			size := tt.size
			if tt.size < 0 {
				size = int64(len(tt.content))
			}
			buffer := make([]byte, size)
			storeFile.Read(buffer)
			storeFile.Close()

			os.RemoveAll(path.Join(os.TempDir(), folder1))

			if string(buffer) != string(tt.expectedContent) {
				t.Errorf("Expected data butts does not equal Actual data %s", string(buffer))
				return
			}
		})
  }
}

func TestDelete(t *testing.T) {
	tests := []struct{
		it string
		id string
    err string
  } {
			{
				it: "should successfully delete data",
				id: "11111111111111111111",
				err: "",
			},
			{
				it: "should return nil-err with non-existent id",
				id: "11111111111111111111",
				err: "",
			},
			{
				it: "should err with invalid id length",
				id: "111111",
				err: "argError: Invalid id length",
			},
		}

	for _, tt := range tests {
		t.Run(tt.it, func(t *testing.T) {
			assert := assert.New(t)

			folder1 := string(tt.id[0:2])
			folder2 := string(tt.id[2:4])
			fileName := string(tt.id[4:])

			createdFilePath := path.Join(os.TempDir(), folder1, folder2, fileName)

			if err := os.MkdirAll(filepath.Dir(createdFilePath), 0700); err != nil {
				t.Errorf("Error: %s when creating dir", err.Error())
				return
			}

			createdFile, err := os.OpenFile(createdFilePath, os.O_RDWR|os.O_CREATE, 0755)
			if err != nil {
				t.Errorf("Error: %s opening created file %s", err.Error(), createdFilePath)
				return
			}

			createdFile.Close()

			err = Delete(tt.id, os.TempDir())
			if tt.err != "" {
				if assert.NotNil(err) {
					assert.Equal(tt.err, err.Error())
				}
				return
			} else if err != nil {
				t.Errorf("Error: %s", err.Error())
				return
			}

			if _, err = os.Stat(createdFilePath); os.IsExist(err) {
				t.Errorf("Error deleting file")
				return
			}
			return
		})
	}
}

func TestDetermineID(t *testing.T) {
	t.Run("should return an id string", func(t *testing.T) {
		assert := assert.New(t)
		id := DetermineID()
		assert.Equal(len(id) >= IDLength, true)
	})

	t.Run("should return a different string on each call", func(t *testing.T) {
		assert := assert.New(t)
		assert.NotEqual(DetermineID(), DetermineID())
	})
}

func TestMain(m *testing.M) {
	m.Run()
}