github.com/Files-com/files-sdk-go/v3@v3.1.81/file/proxyreader_test.go (about)

     1  package file
     2  
     3  import (
     4  	"bytes"
     5  	"io"
     6  	"os"
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestProxyReader_Read_1(t *testing.T) {
    13  	assert := assert.New(t)
    14  
    15  	localFile, err := os.Open("../LICENSE")
    16  	assert.NoError(err)
    17  	reader := &ProxyReaderAt{
    18  		ReaderAt: localFile,
    19  		off:      100,
    20  		len:      101,
    21  		onRead:   nil,
    22  		read:     0,
    23  	}
    24  
    25  	b, err := io.ReadAll(reader)
    26  	assert.NoError(err)
    27  	assert.Equal(101, len(b))
    28  	assert.Equal("granted, free of charge, to any person obtaining a copy\nof this software and associated documentation", string(b))
    29  }
    30  
    31  func TestProxyReader_Read_2(t *testing.T) {
    32  	assert := assert.New(t)
    33  
    34  	localFile, err := os.Open("../LICENSE")
    35  	assert.NoError(err)
    36  	reader := &ProxyReaderAt{
    37  		ReaderAt: localFile,
    38  		off:      10,
    39  		len:      1000,
    40  		onRead:   nil,
    41  		read:     0,
    42  	}
    43  
    44  	b, err := io.ReadAll(reader)
    45  	assert.NoError(err)
    46  	assert.Equal(1000, len(b))
    47  }
    48  
    49  func TestProxyReader_Read_OnRead(t *testing.T) {
    50  	assert := assert.New(t)
    51  	var read int64
    52  	localFile, err := os.Open("../LICENSE")
    53  	assert.NoError(err)
    54  	reader := &ProxyReaderAt{
    55  		ReaderAt: localFile,
    56  		off:      10,
    57  		len:      1000,
    58  		onRead: func(i int64) {
    59  			read += i
    60  		},
    61  		read: 0,
    62  	}
    63  
    64  	b, err := io.ReadAll(reader)
    65  	assert.NoError(err)
    66  	assert.Equal(1000, len(b))
    67  	assert.Equal(int64(1000), read)
    68  	reader.Close()
    69  	//	Can be read again
    70  	b, err = io.ReadAll(reader)
    71  	assert.NoError(err)
    72  	assert.Equal(1000, len(b))
    73  	assert.Equal(int64(1000), read)
    74  }
    75  
    76  func TestProxyReader_ReadWithOnRead(t *testing.T) {
    77  	data := []byte("This is a test string for the ProxyReaderAt implementation.")
    78  	readerAt := bytes.NewReader(data)
    79  
    80  	var bytesRead int64
    81  	onRead := func(i int64) {
    82  		bytesRead += i
    83  	}
    84  
    85  	proxyReader := &ProxyReaderAt{
    86  		ReaderAt: readerAt,
    87  		off:      0,
    88  		len:      int64(len(data)),
    89  		onRead:   onRead,
    90  	}
    91  
    92  	buf := make([]byte, 10)
    93  	n, err := proxyReader.Read(buf)
    94  
    95  	if err != nil {
    96  		t.Errorf("Error reading from ProxyReaderAt: %v", err)
    97  	}
    98  
    99  	if n != 10 {
   100  		t.Errorf("Expected to read 10 bytes, got %d bytes", n)
   101  	}
   102  
   103  	if bytesRead != int64(n) {
   104  		t.Errorf("Expected bytesRead to be %d, got %d", n, bytesRead)
   105  	}
   106  
   107  	if string(buf) != "This is a " {
   108  		t.Errorf("Unexpected read data: %s", buf)
   109  	}
   110  }
   111  
   112  func TestProxyReader_SeekWithOnRead(t *testing.T) {
   113  	data := []byte("This is a test string for the ProxyReaderAt implementation.")
   114  	readerAt := bytes.NewReader(data)
   115  
   116  	var bytesRead int64
   117  	onRead := func(i int64) {
   118  		bytesRead += i
   119  	}
   120  
   121  	proxyReader := &ProxyReaderAt{
   122  		ReaderAt: readerAt,
   123  		off:      0,
   124  		len:      int64(len(data)),
   125  		onRead:   onRead,
   126  	}
   127  
   128  	_, err := proxyReader.Seek(4, io.SeekStart)
   129  
   130  	if err != nil {
   131  		t.Errorf("Error seeking ProxyReaderAt: %v", err)
   132  	}
   133  
   134  	if bytesRead != 4 {
   135  		t.Errorf("Expected bytesRead to be 4, got %d", bytesRead)
   136  	}
   137  
   138  	buf := make([]byte, 4)
   139  	n, err := proxyReader.Read(buf)
   140  
   141  	if err != nil {
   142  		t.Errorf("Error reading from ProxyReaderAt: %v", err)
   143  	}
   144  
   145  	if n != 4 {
   146  		t.Errorf("Expected to read 4 bytes, got %d bytes", n)
   147  	}
   148  
   149  	if bytesRead != 8 {
   150  		t.Errorf("Expected bytesRead to be 8, got %d", bytesRead)
   151  	}
   152  
   153  	if string(buf) != " is " {
   154  		t.Errorf("Unexpected read data: %s", buf)
   155  	}
   156  }
   157  
   158  func TestProxyReader_CloseWithOnRead(t *testing.T) {
   159  	data := []byte("This is a test string for the ProxyReaderAt implementation.")
   160  	readerAt := bytes.NewReader(data)
   161  
   162  	var bytesRead int64
   163  	onRead := func(i int64) {
   164  		bytesRead += i
   165  	}
   166  
   167  	proxyReader := &ProxyReaderAt{
   168  		ReaderAt: readerAt,
   169  		off:      0,
   170  		len:      int64(len(data)),
   171  		onRead:   onRead,
   172  	}
   173  
   174  	buf := make([]byte, 10)
   175  	n, err := proxyReader.Read(buf)
   176  
   177  	if err != nil {
   178  		t.Errorf("Error reading from ProxyReaderAt: %v", err)
   179  	}
   180  
   181  	if n != 10 {
   182  		t.Errorf("Expected to read 10 bytes, got %d bytes", n)
   183  	}
   184  
   185  	if bytesRead != 10 {
   186  		t.Errorf("Expected bytesRead to be 10, got %d", bytesRead)
   187  	}
   188  
   189  	err = proxyReader.Close()
   190  	if err != nil {
   191  		t.Errorf("Error closing ProxyReaderAt: %v", err)
   192  	}
   193  
   194  	// Since the onRead callback is not called during Close(), bytesRead remains the same.
   195  	if bytesRead != 10 {
   196  		t.Errorf("Expected bytesRead to be 10, got %d", bytesRead)
   197  	}
   198  }