Catel - Part 4 of n: Unit testing with Catel

using System;
using System.Collections.Generic;
using System.IO;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Directory = System.IO.Directory;
using File = Catel.IO.File;
using Path = System.IO.Path;

namespace Catel.Test.IO
{
    [TestClass]
    public class FileTest
    {
        #region Variables
        private string _testDirectory;
        #endregion

        #region Initialization & cleanup
        [TestInitialize]
        public void Initialize()
        {
            // Determine test directory
            _testDirectory = Catel.IO.Path.Combine(Path.GetTempPath(), "FileTest");

            // Delete directory, than create it
            if (Directory.Exists(_testDirectory)) Directory.Delete(_testDirectory, true);
            Directory.CreateDirectory(_testDirectory);
        }

        [TestCleanup]
        public void CleanUp()
        {
            // Delete test directory
            if (!string.IsNullOrEmpty(_testDirectory)) Directory.Delete(_testDirectory, true);
        }
        #endregion

        #region Copy
        [TestMethod]
        public void CopyFileWhenDestinationFileDoesNotExist()
        {
            // Declare variables
            string input1 = Catel.IO.Path.Combine(_testDirectory, "TestFile.dat");
            string input2 = Catel.IO.Path.Combine(_testDirectory, "TestFileWithNonExistingDestination.dat");
            bool expectedOutput = true;

            // Create file
            CreateFileWithDummyContent(input1);

            // Copy file
            bool output = Catel.IO.File.Copy(input1, input2);

            // Check result
            Assert.AreEqual(expectedOutput, output);
        }

        [TestMethod]
        public void CopyFileWhenDestinationFileExistButAllowOverwrite()
        {
            // Declare variables
            string input1 = Catel.IO.Path.Combine(_testDirectory, "TestFile.dat");
            string input2 = Catel.IO.Path.Combine(_testDirectory, "TestFileWithExistingDestination.dat");
            bool expectedOutput = true;

            // Create files
            CreateFileWithDummyContent(input1);
            CreateFileWithDummyContent(input2);

            // Copy file
            bool output = Catel.IO.File.Copy(input1, input2, false);

            // Check result
            Assert.AreEqual(expectedOutput, output);
        }

        [TestMethod]
        public void CopyFileWhenDestinationFileExistAndDoNotAllowOverwrite()
        {
            // Declare variables
            string input1 = Catel.IO.Path.Combine(_testDirectory, "TestFile.dat");
            string input2 = Catel.IO.Path.Combine(_testDirectory, "TestFileWithExistingDestination.dat");
            bool expectedOutput = false;

            // Create files
            CreateFileWithDummyContent(input1);
            CreateFileWithDummyContent(input2);

            // Copy file
            bool output = Catel.IO.File.Copy(input1, input2, true);

            // Check result
            Assert.AreEqual(expectedOutput, output);
        }
        #endregion

        #region Create
        [TestMethod]
        public void CreateFile()
        {
            string fileName = Path.Combine(_testDirectory, "CreateFileTest.txt");
            using (TextWriter stream = new StreamWriter(File.Create(fileName)))
            {
                stream.WriteLine("test");
            }

            Assert.IsTrue(File.Exists(fileName));
        }
        #endregion

        #region Delete
        [TestMethod]
        public void DeleteFile_ExistingFile()
        {
            string fileName = Path.Combine(_testDirectory, "DeleteFile_ExistingFile.txt");
            CreateFileWithDummyContent(fileName);

            Assert.IsTrue(File.Exists(fileName));
            Assert.IsTrue(File.Delete(fileName));
            Assert.IsFalse(File.Exists(fileName));
        }

        [TestMethod]
        public void DeleteFile_NonExistingFile()
        {
            string fileName = Path.Combine(_testDirectory, "DeleteFile_NonExistingFile.txt");

            Assert.IsFalse(File.Exists(fileName));
            Assert.IsFalse(File.Delete(fileName));
            Assert.IsFalse(File.Exists(fileName));
        }
        #endregion

        #region Exists
        [TestMethod]
        public void Exists_Null()
        {
            try
            {
                File.Exists(null);
                Assert.Fail("Expected exception");
            }
            catch (ArgumentException ex)
            {
                Assert.AreEqual(ex.ParamName, "filePath");
            }
        }

        [TestMethod]
        public void Exists_EmptyString()
        {
            Assert.AreEqual(false, File.Exists(string.Empty));
        }

        [TestMethod]
        public void Exists_ExistingFile()
        {
            // Declare variables
            string input = @"C:\Windows\Notepad.exe";
            bool expectedOutput = true;

            // Call method
            bool output = Catel.IO.File.Exists(input);

            // Check result
            Assert.AreEqual(expectedOutput, output);
        }

        [TestMethod]
        public void Exists_NonExistingFile()
        {
            // Declare variables
            string input = @"C:\Windows\NonExistingNotepad.exe";
            bool expectedOutput = false;

            // Call method
            bool output = Catel.IO.File.Exists(input);

            // Check result
            Assert.AreEqual(expectedOutput, output);
        }
        #endregion

        #region GetFileSize
        [TestMethod]
        public void GetFileSize_NonExistingFile()
        {
            string fileName = Path.Combine(_testDirectory, "GetFileSize_NonExistingFile.txt");

            Assert.IsFalse(File.Exists(fileName));
            Assert.AreEqual(0, File.GetFileSize(fileName));
        }

        [TestMethod]
        public void GetFileSize_EmptyFile()
        {
            string fileName = Path.Combine(_testDirectory, "GetFileSize_EmptyFile.txt");
            using (FileStream stream = File.Create(fileName))
            {
                stream.Write(new byte[] {}, 0, 0);
            }

            Assert.IsTrue(File.Exists(fileName));
            Assert.AreEqual(0, File.GetFileSize(fileName));
        }

        [TestMethod]
        public void GetFileSize_1024Bytes()
        {
            string fileName = Path.Combine(_testDirectory, "GetFileSize_1024Bytes.txt");
            using (FileStream stream = File.Create(fileName))
            {
                stream.Write(GetBytes(1024), 0, 1024);
            }

            Assert.IsTrue(File.Exists(fileName));
            Assert.AreEqual(1024, File.GetFileSize(fileName));
        }
        #endregion

        #region Open
        [TestMethod]
        public void OpenFile_ExistingFile_ReadWrite()
        {
            string fileName = Path.Combine(_testDirectory, "OpenFile_ExistingFile_ReadWrite.txt");
            CreateFileWithDummyContent(fileName);

            using (FileStream fileStream = File.Open(fileName, FileMode.Open))
            {
                Assert.IsTrue(fileStream.CanWrite);
                Assert.IsTrue(fileStream.CanRead);
            }
        }

        [TestMethod]
        public void OpenFile_ExistingFile_ReadOnly()
        {
            string fileName = Path.Combine(_testDirectory, "OpenFile_ExistingFile_ReadOnly.txt");
            CreateFileWithDummyContent(fileName);

            using (FileStream fileStream = File.Open(fileName, FileMode.Open, FileAccess.Read))
            {
                Assert.IsFalse(fileStream.CanWrite);
                Assert.IsTrue(fileStream.CanRead);
            }
        }

        [TestMethod]
        public void OpenFile_ExistingFile_WriteOnly()
        {
            string fileName = Path.Combine(_testDirectory, "OpenFile_ExistingFile_WriteOnly.txt");
            CreateFileWithDummyContent(fileName);

            using (FileStream fileStream = File.Open(fileName, FileMode.Open, FileAccess.Write))
            {
                Assert.IsTrue(fileStream.CanWrite);
                Assert.IsFalse(fileStream.CanRead);
            }
        }

        [TestMethod]
        [ExpectedException(typeof(FileNotFoundException))]
        public void OpenFile_NonExistingFile()
        {
            string fileName = Path.Combine(_testDirectory, "OpenFile_NonExistingFile.txt");
            File.Open(fileName, FileMode.Open);
        }
        #endregion

        #region Helper methods
        /// <summary>
        /// Creates a file with dummary content.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        private static void CreateFileWithDummyContent(string fileName)
        {
            using (FileStream fileStream = Catel.IO.File.OpenWrite(fileName))
            {
                TextWriter writer = new StreamWriter(fileStream);
                writer.Write("File contents");
                writer.Close();
            }
        }

        /// <summary>
        /// Gets an array of bytes.
        /// </summary>
        /// <param name="size">The size.</param>
        /// <returns>Array of bytes of the specific size</returns>
        private static byte[] GetBytes(int size)
        {
            List<byte> bytes = new List<byte>();
            for (int i = 0; i < size; i++)
            {
                bytes.Add(1);
            }
            return bytes.ToArray();
        }
        #endregion
    }
}