|
public static Create ( |
||
| uri | ||
| computeHashes | bool | |
| return | ||
public void FileData_PersistTextFileContentsBigEndianUnicode()
{
Encoding encoding = Encoding.BigEndianUnicode;
string filePath = Path.GetTempFileName() + ".cs";
string textValue = "अचम्भा";
byte[] fileContents = encoding.GetBytes(textValue);
Uri uri = new Uri(filePath);
try
{
File.WriteAllBytes(filePath, fileContents);
FileData fileData = FileData.Create(uri, OptionallyEmittedData.TextFiles, mimeType: null, encoding: encoding);
fileData.FileLocation.Should().Be(null);
fileData.MimeType.Should().Be(MimeType.CSharp);
fileData.Hashes.Should().BeNull();
string encodedFileContents = encoding.GetString(fileContents);
fileData.Contents.Text.Should().Be(encodedFileContents);
}
finally
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
public void FileData_FileIsLocked()
{
string filePath = Path.GetTempFileName();
Uri uri = new Uri(filePath);
try
{
// Place an exclusive read lock on file, so that FileData cannot access its contents.
// This raises an IOException, which is swallowed by FileData.Create
using (var exclusiveAccessReader = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.None))
{
FileData fileData = FileData.Create(uri, OptionallyEmittedData.TextFiles);
fileData.FileLocation.Should().Be(null);
fileData.MimeType.Should().Be(MimeType.Binary);
fileData.Hashes.Should().BeNull();
fileData.Contents.Should().BeNull();
}
}
finally
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
public void FileData_PersistFileContentsUtf8()
{
string filePath = Path.GetTempFileName() + ".cs";
string textValue = "अचम्भा";
byte[] fileContents = Encoding.BigEndianUnicode.GetBytes(textValue);
Uri uri = new Uri(filePath);
try
{
File.WriteAllBytes(filePath, fileContents);
FileData fileData = FileData.Create(uri, LoggingOptions.PersistFileContents, mimeType: null, encoding: Encoding.BigEndianUnicode);
fileData.Uri.Should().Be(null);
fileData.MimeType.Should().Be(MimeType.CSharp);
fileData.Hashes.Should().BeNull();
string encodedFileContents = Convert.ToBase64String(Encoding.UTF8.GetBytes(textValue));
fileData.Contents.Should().Be(encodedFileContents);
}
finally
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
public void FileData_PersistFileContentsBinary()
{
string filePath = Path.GetTempFileName();
string fileContents = Guid.NewGuid().ToString();
Uri uri = new Uri(filePath);
try
{
File.WriteAllText(filePath, fileContents);
FileData fileData = FileData.Create(uri, LoggingOptions.PersistFileContents);
fileData.Uri.Should().Be(null);
fileData.MimeType.Should().Be(MimeType.Binary);
fileData.Hashes.Should().BeNull();
string encodedFileContents = Convert.ToBase64String(File.ReadAllBytes(filePath));
fileData.Contents.Should().Be(encodedFileContents);
}
finally
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
public void FileData_FileDoesNotExist()
{
// If a file does not exist, and we request file contents
// persistence, the logger will not raise an exception
string filePath = Path.GetTempFileName();
Uri uri = new Uri(filePath);
FileData fileData = FileData.Create(uri, OptionallyEmittedData.TextFiles);
fileData.FileLocation.Should().Be(null);
fileData.MimeType.Should().Be(MimeType.Binary);
fileData.Hashes.Should().BeNull();
fileData.Contents.Should().BeNull();
}
public void FileData_FileDoesNotExist()
{
// If a file does not exist, and we request file contents
// persistence, the logger will not raise an exception
string filePath = Path.GetTempFileName();
Uri uri = new Uri(filePath);
FileData fileData = FileData.Create(uri, LoggingOptions.PersistFileContents);
fileData.Uri.Should().Be(null);
fileData.MimeType.Should().Be(MimeType.Binary);
fileData.Hashes.Should().BeNull();
fileData.Contents.Should().Be(String.Empty);
}
public void FileData_SerializeMultipleFileRoles()
{
FileData fileData = FileData.Create(new Uri("file:///foo.cs"), OptionallyEmittedData.None);
fileData.Roles = FileRoles.ResponseFile | FileRoles.ResultFile;
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
ContractResolver = SarifContractResolver.Instance
};
string actual = JsonConvert.SerializeObject(fileData);
actual.Should().Be("{\"roles\":[\"responseFile\",\"resultFile\"],\"mimeType\":\"text/x-csharp\"}");
}
public void FileData_SerializeSingleFileRole()
{
FileData fileData = FileData.Create(new Uri("file:///foo.cs"), OptionallyEmittedData.None);
fileData.Roles = FileRoles.AnalysisTarget;
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
ContractResolver = SarifContractResolver.Instance
};
string result = JsonConvert.SerializeObject(fileData);
result.Should().Be("{\"roles\":[\"analysisTarget\"],\"mimeType\":\"text/x-csharp\"}");
}
public void FileData_PersistBinaryAndTextFileContents(
string fileExtension,
OptionallyEmittedData dataToInsert,
bool shouldBePersisted)
{
string filePath = Path.GetTempFileName() + fileExtension;
string fileContents = Guid.NewGuid().ToString();
Uri uri = new Uri(filePath);
try
{
File.WriteAllText(filePath, fileContents);
FileData fileData = FileData.Create(uri, dataToInsert);
fileData.FileLocation.Should().BeNull();
if (dataToInsert.Includes(OptionallyEmittedData.Hashes))
{
fileData.Hashes.Should().NotBeNull();
}
else
{
fileData.Hashes.Should().BeNull();
}
string encodedFileContents = Convert.ToBase64String(File.ReadAllBytes(filePath));
if (shouldBePersisted)
{
fileData.Contents.Binary.Should().Be(encodedFileContents);
fileData.Contents.Text.Should().BeNull();
}
else
{
fileData.Contents.Should().BeNull();
}
}
finally
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
private static void RunUnauthorizedAccessTextForFile(bool isTextFile)
{
string extension = isTextFile ? ".cs" : ".dll";
string filePath = Path.GetFullPath(Guid.NewGuid().ToString()) + extension;
Uri uri = new Uri(filePath);
IFileSystem fileSystem = SetUnauthorizedAccessExceptionMock();
FileData fileData = FileData.Create(
uri,
OptionallyEmittedData.TextFiles,
mimeType: null,
encoding: null,
fileSystem: fileSystem);
// We pass none here as the occurrence of UnauthorizedAccessException
// should result in non-population of any file contents.
Validate(fileData, OptionallyEmittedData.None);
}
public void FileData_ComputeHashes()
{
string filePath = Path.GetTempFileName();
string fileContents = Guid.NewGuid().ToString();
Uri uri = new Uri(filePath);
try
{
File.WriteAllText(filePath, fileContents);
FileData fileData = FileData.Create(uri, OptionallyEmittedData.Hashes);
fileData.FileLocation.Should().Be(null);
HashData hashes = HashUtilities.ComputeHashes(filePath);
fileData.MimeType.Should().Be(MimeType.Binary);
fileData.Contents.Should().BeNull();
fileData.Hashes.Count.Should().Be(3);
foreach (Hash hash in fileData.Hashes)
{
switch (hash.Algorithm)
{
case "md5": { hash.Value.Should().Be(hashes.MD5); break; }
case "sha-1": { hash.Value.Should().Be(hashes.Sha1); break; }
case "sha-256": { hash.Value.Should().Be(hashes.Sha256); break; }
default: { true.Should().BeFalse(); break; /* unexpected algorithm kind */ }
}
}
}
finally
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
public void FileData_Create_NullUri()
{
Action action = () => { FileData.Create(null, OptionallyEmittedData.None); };
action.ShouldThrow <ArgumentNullException>();
}
public void FileData_Create_NullUri()
{
Action action = () => { FileData.Create(null, LoggingOptions.None); };
action.ShouldThrow <ArgumentNullException>();
}
