require('../../src/fluentnode')
expect = require('chai').expect
describe '| fs',->
file_Contents = null
tmp_File = null
tmp_Folder = null
beforeEach ->
file_Contents = 'aaaa_'.add_5_Letters()
tmp_Folder = '_temp_Folder_'.add_5_Letters().folder_Create() .folder_Name()
tmp_File = '_temp_File_' .add_5_Letters().file_Create(file_Contents).file_Name()
afterEach ->
tmp_File .file_Delete()
tmp_Folder.folder_Delete()
it 'create_Parent_Folder', ->
'./aaa/abc.txt'.create_Parent_Folder().assert_Is './aaa/abc.txt'
'./aaa'.assert_Folder_Exists()
"./aaa".delete_Folder().assert_True()
it 'folder_Create and folder_Delete' , ->
''.folder_Create.assert_Is_Function()
''.folder_Delete.assert_Is_Function()
tmpDir = "./".temp_Name_In_Folder()
tmpDir.assert_Folder_Not_Exists()
.folder_Create().assert_Is tmpDir.realPath()
tmpDir.assert_Folder_Exists()
.folder_Delete().assert_Is_True()
tmpDir.assert_Folder_Not_Exists()
''.folder_Delete.assert_Is ''.delete_Folder
it 'folder_Create (and its parent)', ->
tmpDir = "./".temp_Name_In_Folder()
tmpDir2 = tmpDir.path_Combine('aaa')
tmpDir2.create_Dir().assert_That_Folder_Exists()
tmpDir.folder_Delete_Recursive().assert_Is_True()
it 'folder_Delete_Recursive' , ->
tmpDir = "./" .temp_Name_In_Folder().folder_Create()
tmpFile = tmpDir.temp_Name_In_Folder().file_Create()
tmpDir.folder_Delete_Recursive().assert_Is_True()
tmpFile.assert_File_Not_Exists()
it 'file_Append', (done)->
original_Contents = tmp_File.file_Contents()
extra_Contents_1 = "_bbbb".add_5_Letters()
extra_Contents_2 = "_aaaa_".add_5_Letters()
tmp_File.file_Append extra_Contents_1
tmp_File.file_Contents().assert_Is original_Contents + extra_Contents_1
tmp_File.file_Append extra_Contents_2, (fileName)->
fileName.assert_Is tmp_File.real_Path()
tmp_File.file_Contents().assert_Is original_Contents + extra_Contents_1 + extra_Contents_2
done()
it 'file_Create and file_Delete',->
tmpName = '.'.temp_Name_In_Folder()
tmpName.file_Create().assert_Is(tmpName)
tmpName.exists() .assert_True()
tmpName.file_Delete().assert_True()
tmpName.exists() .assert_False()
tmpName.file_Create('abc123')
tmpName.assert_File_Contents('abc123')
tmpName.assert_File_Deleted()
it 'file_Copy' , ->
file1 = '.'.temp_Name_In_Folder()
file2 = '.'.temp_Name_In_Folder()
file1.file_Create().assert_Is(file1)
file1.assert_File_Exists()
file1.file_Copy(file2)
file2.assert_File_Exists()
folder = '_tmp_file_Copy'.folder_Create()
file_In_Folder = file1.file_Copy(folder)
file_In_Folder.assert_File_Exists()
assert_Is_Null('aaa'.file_Copy('bbb'))
assert_Is_Null(file1.file_Copy(null))
folder.folder_Delete_Recursive().assert_True()
file1.file_Delete().assert_True()
file2.file_Delete().assert_True()
it 'file_Contents' , ->
''.file_Contents.assert_Is_Function()
file_Name = '_temp_name_'.add_Random_String(5)
file_Contents = 'value_'.add_Random_String(5)
(file_Name.file_Exists().assert_Is_False())
file_Contents.save_As(file_Name)
file_Name.file_Exists().assert_Is_True()
file_Name.file_Contents().assert_Is(file_Contents)
file_Name.file_Delete().assert_Is_True()
it 'file_Exists' , ->
''.file_Exists.assert_Is_Function()
tmp_Folder .file_Exists().assert_Is_True()
tmp_File .file_Exists().assert_Is_True()
'./aaa.js' .file_Exists().assert_Is_False()
'./aaa.js' .file_Exists().assert_Is_False()
it 'file_Lines', ->
"".file_Lines().assert_Is []
tmp_File = "aaaa\nbbbb".save_As('_tmp_file_Lines')
tmp_File.file_Lines().assert_Is ['aaaa','bbbb']
tmp_File.assert_File_Deleted()
it 'file_Not_Exists' , ->
''.file_Not_Exists.assert_Is_Function()
tmp_Folder .file_Not_Exists().assert_Is_False()
'./index.js'.file_Not_Exists().assert_Is_True()
'./aaa.js' .file_Not_Exists().assert_Is_True()
it 'file_Write',->
content = (20).random_Letters()
tmpFile = './src'.fullPath().path_Combine('_temp_file.abcd').assert_File_Not_Exists()
.file_Write(content)
tmpFile.assert_File_Exists()
.file_Contents().assert_Is(content)
tmpFile.file_Delete().assert_Is_True()
it 'files_And_Folders',->
''.files_And_Folders.assert_Is_Function()
files = './'.files_And_Folders();
files.assert_Contains tmp_File .realPath()
.assert_Contains tmp_Folder .realPath()
.assert_Not_Contains '.aaaaa'.realPath()
'aaaa'.files_And_Folders().assert_Is([])
it 'files' , ->
''.files.assert_Is_Function()
tmp_File_2 = '_temp_File_' .add_5_Letters().file_Create(file_Contents).file_Name()
files = './'.files()
expectedFiles = [tmp_File.real_Path(), tmp_File_2.real_Path()]
files.assert_Contains(expectedFiles)
tmp_File_2.assert_File_Deleted()
it 'files_Recursive' , ->
extension = __filename.file_Extension().replace('coffee', 'litcoffee')
file_To_Find = "./src/node-native/fs#{extension}".fullPath()
''.files_Recursive.assert_Is_Function()
'./src'.files_Recursive().assert_Size_Is_Bigger_Than(9)
.assert_Contains(file_To_Find)
tmpFile = './src'.fullPath().path_Combine('_temp_file.abcd').file_Write((20).random_Letters())
'./src'.files_Recursive('.abcd').assert_Size_Is(1)
.first().assert_Is(tmpFile)
tmpFile.file_Delete().assert_Is_True()
it 'folders' , ->
''.folders.assert_Is_Function()
folders = '.'.folders()
expectedFolders = (folder.realPath() for folder in 'src,test'.split(','))
folders.assert_Contains(expectedFolders)
it 'is_Folder', ->
'' .is_Folder .assert_Is_Function()
tmp_Folder .is_Folder().assert_Is_True()
tmp_File .is_Folder().assert_Is_False()
'.gitAAA' .is_Folder().assert_Is_False()
it 'is_Not_Folder',->
"".add_5_Random_Letters().is_Not_Folder().assert_Is_True()
it 'is_File', ->
''.is_File .assert_Is_Function()
tmp_Folder .is_File().assert_Is_False()
tmp_File .is_File().assert_Is_True()
'.gitAAA' .is_File().assert_Is_False()
it 'realPath', ->
tmp_Folder.realPath().assert_Is process.cwd().path_Combine tmp_Folder
tmp_File .realPath().assert_Is process.cwd().path_Combine tmp_File
assert_Is_Null '.gitignore2' .realPath()
it 'save_As', ->
file_Name = '_tmp_file_'.add_Random_String(5)
file_Value1 = 'value' .add_Random_String(5)
file_Value2 = 'value' .add_Random_String(5)
file_Name.exists().assert_Is_False()
file_Value1.save_As(file_Name).assert_Is(file_Name.real_Path()).assert_File_Exists()
file_Name.exists() .assert_Is_True()
file_Name.file_Contents() .assert_Is (file_Value1)
file_Name.file_Contents() .assert_Is_Not(file_Value2)
file_Value2.save_As(file_Name).assert_Is(file_Name.real_Path()).assert_File_Exists()
file_Name.exists() .assert_Is_True()
file_Name.file_Contents() .assert_Is_Not(file_Value1)
file_Name.file_Contents() .assert_Is (file_Value2)
file_Name.file_Delete() .assert_Is_True()
''.save_As.assert_Is ''.saveAs
it 'Save_As file path must be 255 characters max', ->
file_Name = '_tmp_file_'.add_Random_String(245)
file_Content = ''.add_Random_String(100);
file_Name.length.assert_Is(255);
file_Content.save_As(file_Name)
.assert_File_Exists()
.assert_File_Deleted()
it 'Save_As file path must be 255 characters max (file must not be created)', ->
file_Name = '_tmp_file_'.add_Random_String(1000)
file_Content = ''.add_Random_String(100);
file_Name.length .assert_Is(1010);
file_Content .save_As(file_Name)
.assert_Is_False()
file_Name.exists() .assert_Is_False()
it 'temp_File',->
value = "abc".add_5_Letters()
'./'.temp_File(value).assert_File_Exists()
.assert_File_Contents(value)
.assert_File_Deleted()
assert_Is_Null 'aaaaaa'.temp_File()
it 'temp_Name_In_Folder', ->
tmpName = './'.temp_Name_In_Folder()
expect(tmpName ).to.contain('./'.realPath())
expect(tmpName ).to.contain('_tmp_')
expect(tmpName.size()).to.equal('./'.realPath().size()+16)
it 'touch',->
expect(''.touch).to.be.an('function')
tempFile = '.'.temp_Name_In_Folder().touch()
expect(tempFile.file_Exists()).to.be.true
expect(tempFile.file_Delete()).to.be.true
it 'exists' , -> expect('.git'.exists ).to.equal(".git".file_Exists)
it 'create_Dir' , -> expect('.git'.create_Dir ).to.equal(".git".folder_Create)
it 'folder_Exists', -> expect('.git'.folder_Exists).to.equal(".git".is_Folder)
it 'is_Directory' , -> expect('.git'.is_Directory ).to.equal(".git".is_Folder)
