public async Task ValidateSubjectName_SubjectNameNotUnique()
{
var release = new Release();
var dataReleaseFile = new ReleaseFile
{
Release = release,
Name = "Subject Title",
File = new File
{
Type = FileType.Data,
}
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddAsync(release);
await contentDbContext.AddAsync(dataReleaseFile);
await contentDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var(service, _) = BuildService(contentDbContext);
var result = await service.ValidateSubjectName(release.Id, "Subject Title");
result.AssertBadRequest(SubjectTitleMustBeUnique);
}
}
private List <ReleaseFile> GetReleaseFiles()
{
List <ReleaseFile> fileList = new List <ReleaseFile>();
foreach (ITaskItem item in this.releaseFileItems)
{
string filePath = null;
try
{
if (item.ItemSpec.Length != 0)
{
filePath = item.GetMetadata("FullPath");
using (Stream fileStream = File.OpenRead(filePath))
{
ReleaseFile file = new ReleaseFile(ReleaseTaskBase.GetMetadata(item, "Name"), ReleaseTaskBase.GetMetadata(item, "MimeType"), item.GetMetadata("Filename") + item.GetMetadata("Extension"), fileStream, base.GetEnumValue <ReleaseFileType>(ReleaseTaskBase.GetMetadata(item, "FileType") ?? "RuntimeBinary"));
fileList.Add(file);
base.LogMessage(" \"{0}\" as \"{1}\"", new object[] { file.FileName, file.Name ?? Path.GetFileName(file.FileName) });
}
}
}
catch (ArgumentException)
{
throw;
}
catch (Exception)
{
if (filePath != null)
{
base.LogError("Unable to open file: {0}", new object[] { filePath });
}
}
}
return(fileList);
}
public async Task <BlobInfo?> Get(ReleaseFile releaseFile)
{
return(await _blobStorageService.FindBlob(
containerName : BlobContainers.PrivateReleaseFiles,
path : releaseFile.File.Path()
));
}
public void ItReturnsTrueIfValuesAreEquals()
{
ReleaseFile f1 = new ReleaseFile("abcdef", "foo", "win-x86", "https://here.there.com");
ReleaseFile f2 = new ReleaseFile("abcdef", "foo", "win-x86", "https://here.there.com");
Assert.Equal(f1, f2);
}
public void ItReturnsFalseIfReferenceEquals2()
{
ReleaseFile f1 = new ReleaseFile("abcdef", "Foo", "win-x86", "https://here.there.com");
ReleaseFile f2 = new ReleaseFile("abcdef", "foo", "win-x86", "https://here.there.com");
Assert.NotEqual(f1, f2);
}
public void ToFileInfo_NoCreatedBy()
{
var releaseFile = new ReleaseFile
{
Release = new Release(),
Name = "Test ancillary file",
File = new File
{
Id = Guid.NewGuid(),
RootPath = Guid.NewGuid(),
Filename = "ancillary.pdf",
Type = Ancillary,
}
};
var info = releaseFile.ToFileInfo(new BlobInfo
(
path: "Ignored",
size: "400 B",
contentType: "Ignored",
contentLength: -1L,
meta: new Dictionary <string, string>()
));
Assert.Null(info.Created);
Assert.Null(info.UserName);
}
public async Task <ReleaseFile> Create(
Guid releaseId,
string filename,
FileType type,
Guid createdById,
string?name = null,
string?summary = null)
{
if (!SupportedFileTypes.Contains(type))
{
throw new ArgumentOutOfRangeException(nameof(type), type, "Cannot create file for file type");
}
var releaseFile = new ReleaseFile
{
ReleaseId = releaseId,
Name = name,
Summary = summary,
File = new File
{
Created = DateTime.UtcNow,
CreatedById = createdById,
RootPath = releaseId,
Filename = filename,
Type = type
}
};
var created = (await _contentDbContext.ReleaseFiles.AddAsync(releaseFile)).Entity;
await _contentDbContext.SaveChangesAsync();
return(created);
}
private List<ReleaseFile> GetReleaseFiles()
{
List<ReleaseFile> fileList = new List<ReleaseFile>();
foreach ( ITaskItem item in this.releaseFileItems )
{
string filePath = null;
try
{
if ( item.ItemSpec.Length != 0 )
{
filePath = item.GetMetadata( "FullPath" );
using ( Stream fileStream = File.OpenRead( filePath ) )
{
ReleaseFile file = new ReleaseFile( ReleaseTaskBase.GetMetadata( item, "Name" ), ReleaseTaskBase.GetMetadata( item, "MimeType" ), item.GetMetadata( "Filename" ) + item.GetMetadata( "Extension" ), fileStream, base.GetEnumValue<ReleaseFileType>( ReleaseTaskBase.GetMetadata( item, "FileType" ) ?? "RuntimeBinary" ) );
fileList.Add( file );
base.LogMessage( " \"{0}\" as \"{1}\"", new object[] { file.FileName, file.Name ?? Path.GetFileName( file.FileName ) } );
}
}
}
catch ( ArgumentException )
{
throw;
}
catch ( Exception )
{
if ( filePath != null )
{
base.LogError( "Unable to open file: {0}", new object[] { filePath } );
}
}
}
return fileList;
}
public void DeleteAll()
{
var releaseFile = new ReleaseFile
{
Release = _release,
File = new File
{
Filename = "ancillary.pdf",
Type = Ancillary,
Release = _release
}
};
var contentDbContextId = Guid.NewGuid().ToString();
using (var contentDbContext = DbUtils.InMemoryApplicationDbContext(contentDbContextId))
{
contentDbContext.AddAsync(releaseFile);
contentDbContext.SaveChangesAsync();
}
PolicyCheckBuilder <SecurityPolicies>()
.ExpectResourceCheckToFail(_release, CanUpdateSpecificRelease)
.AssertForbidden(
userService =>
{
var service = SetupReleaseFileService(
contentDbContext: DbUtils.InMemoryApplicationDbContext(contentDbContextId),
userService: userService.Object);
return(service.DeleteAll(_release.Id));
}
);
}
public async Task ItThrowsIfDestinationPathIsNull()
{
ProductRelease release = GetProductRelease("2.1", "2.1.8");
ReleaseFile file = release.Files.FirstOrDefault();
Func <Task> f = async() => await file.DownloadAsync(null);
ArgumentNullException exception = await Assert.ThrowsAsync <ArgumentNullException>(f);
}
public async Task Get()
{
var release = new Release
{
MetaGuidance = "Release Meta Guidance"
};
var releaseFile = new ReleaseFile
{
Release = release,
File = new File
{
Filename = "file1.csv",
Release = release,
Type = FileType.Data,
SubjectId = Guid.NewGuid()
}
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddAsync(release);
await contentDbContext.AddAsync(releaseFile);
await contentDbContext.SaveChangesAsync();
}
var metaGuidanceSubjectService = new Mock <IMetaGuidanceSubjectService>(MockBehavior.Strict);
metaGuidanceSubjectService.Setup(mock =>
mock.GetSubjects(release.Id, new List <Guid>
{
releaseFile.File.SubjectId.Value
})).ReturnsAsync(SubjectMetaGuidance);
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var service = SetupMetaGuidanceService(contentDbContext: contentDbContext,
metaGuidanceSubjectService: metaGuidanceSubjectService.Object);
var result = await service.Get(release.Id);
Assert.True(result.IsRight);
metaGuidanceSubjectService.Verify(mock =>
mock.GetSubjects(release.Id, new List <Guid>
{
releaseFile.File.SubjectId.Value
}), Times.Once);
Assert.Equal(release.Id, result.Right.Id);
Assert.Equal("Release Meta Guidance", result.Right.Content);
Assert.Equal(SubjectMetaGuidance, result.Right.Subjects);
}
}
public void Path_ReleaseFile()
{
var releaseFile = new ReleaseFile
{
File = _file
};
Assert.Equal(_file.Path(), releaseFile.Path());
}
public static FileInfo ToFileInfoNotFound(this ReleaseFile releaseFile)
{
var fileInfo = releaseFile.ToPublicFileInfoNotFound();
fileInfo.UserName = releaseFile.File.CreatedBy?.Email;
fileInfo.Created = releaseFile.File.Created;
return(fileInfo);
}
public static FileInfo ToFileInfo(this ReleaseFile releaseFile, BlobInfo blobInfo)
{
var info = releaseFile.ToPublicFileInfo(blobInfo);
info.Created = releaseFile.File.Created;
info.UserName = releaseFile.File.CreatedBy?.Email;
return(info);
}
public async Task ItThrowsIfDestinationPathIsEmpty()
{
ProductRelease release = GetProductRelease("2.1", "2.1.8");
ReleaseFile file = release.Files.FirstOrDefault();
Func <Task> f = async() => await file.DownloadAsync("");
ArgumentException exception = await Assert.ThrowsAsync <ArgumentException>(f);
Assert.Equal($"Value cannot be empty.{Environment.NewLine}Parameter name: destinationPath", exception.Message);
}
private async Task HydrateReleaseFile(ReleaseFile releaseFile)
{
await _contentDbContext.Entry(releaseFile)
.Reference(rf => rf.File)
.LoadAsync();
await _contentDbContext.Entry(releaseFile.File)
.Reference(f => f.CreatedBy)
.LoadAsync();
}
public static FileInfo ToPublicFileInfoNotFound(this ReleaseFile releaseFile)
{
return(new FileInfo
{
Id = releaseFile.FileId,
FileName = releaseFile.File.Filename,
Name = releaseFile.Name ?? releaseFile.File.Filename,
Summary = releaseFile.Summary,
Size = FileInfo.UnknownSize,
Type = releaseFile.File.Type,
});
}
public static FileInfo ToPublicFileInfo(this ReleaseFile releaseFile, BlobInfo blobInfo)
{
return(new FileInfo
{
Id = releaseFile.FileId,
FileName = releaseFile.File.Filename,
Name = releaseFile.Name ?? releaseFile.File.Filename,
Summary = releaseFile.Summary,
Size = blobInfo.Size,
Type = releaseFile.File.Type,
});
}
private static void AssertAmendedReleaseFileCorrect(ReleaseFile originalFile, ReleaseFile amendmentDataFile,
Release amendment)
{
// assert it's a new link table entry between the Release amendment and the data file reference
Assert.NotEqual(originalFile.Id, amendmentDataFile.Id);
Assert.Equal(amendment, amendmentDataFile.Release);
Assert.Equal(amendment.Id, amendmentDataFile.ReleaseId);
// and assert that the file referenced is the SAME file reference as linked from the original Release's
// link table entry
Assert.Equal(originalFile.File.Id, amendmentDataFile.File.Id);
}
public async Task CanCreateReleaseFile_FailOnFolderNotExisting()
{
var dummyReleaseFileEntries = CreateReleaseFiles();
var fileLocation = Randomizer.GetString();
if (Directory.Exists(fileLocation))
{
Directory.Delete(fileLocation, true);
}
Assert.False(await ReleaseFile.CreateReleaseFile(dummyReleaseFileEntries, fileLocation),
"Creating RELEASE file passed even when we had no folder to work with");
}
public async Task CanCreateReleaseFile()
{
var dummyReleaseFileEntries = CreateReleaseFiles();
Assert.True(
await ReleaseFile.CreateReleaseFile(dummyReleaseFileEntries, TestContext.CurrentContext.WorkDirectory),
"Wasn't able to create the release file");
Assert.True(
dummyReleaseFileEntries.SequenceEqual(
ReleaseFile.ReadReleaseFile(File.ReadLines(ReleaseFileLocation))),
"What we made and what we read from disk isn't the same");
}
public static UpdateInfo?GetUpdateInfo(string fileLocation, ApplicationMetadata metadata, bool grabDeltaUpdates, object?tag = null, string?folderLocation = null)
{
if (!File.Exists(fileLocation))
{
Logger.Error("{0} doesn't exist, can't get UpdateInfo", fileLocation);
return(null);
}
return(new UpdateInfo(metadata.ApplicationVersion,
ReleaseFile.ReadReleaseFile(File.ReadLines(fileLocation))
.ToReleaseEntries(folderLocation ?? metadata.TempFolder, tag)
.FilterReleases(metadata.ApplicationFolder, grabDeltaUpdates, metadata.ApplicationVersion).ToArray()));
}
public async Task Validate_SubjectMetaGuidanceNotPopulated()
{
var release = new Release
{
MetaGuidance = "Release Meta Guidance"
};
var releaseFile = new ReleaseFile
{
Release = release,
File = new File
{
Filename = "file1.csv",
Release = release,
Type = FileType.Data,
SubjectId = Guid.NewGuid()
}
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddAsync(release);
await contentDbContext.AddAsync(releaseFile);
await contentDbContext.SaveChangesAsync();
}
var metaGuidanceSubjectService = new Mock <IMetaGuidanceSubjectService>(MockBehavior.Strict);
metaGuidanceSubjectService.Setup(mock => mock.Validate(release.Id))
.ReturnsAsync(false);
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var service = SetupMetaGuidanceService(contentDbContext: contentDbContext,
metaGuidanceSubjectService: metaGuidanceSubjectService.Object);
var result = await service.Validate(release.Id);
Assert.True(result.IsLeft);
metaGuidanceSubjectService.Verify(mock => mock.Validate(release.Id), Times.Once);
ValidationTestUtil.AssertValidationProblem(result.Left, PublicMetaGuidanceRequired);
}
}
public async Task ListSubjects_FiltersSubjectsWithNoFileSubjectId()
{
var releaseId = Guid.NewGuid();
var release = new Release
{
Id = releaseId
};
var releaseFile = new ReleaseFile
{
Release = release,
File = new File
{
Filename = "data1.csv",
Type = FileType.Data,
}
};
var import = new DataImport
{
File = releaseFile.File,
Status = DataImportStatus.COMPLETE
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryContentDbContext(contentDbContextId))
{
await contentDbContext.AddAsync(release);
await contentDbContext.AddRangeAsync(releaseFile);
await contentDbContext.AddRangeAsync(import);
await contentDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryContentDbContext(contentDbContextId))
{
var service = BuildReleaseService(contentDbContext: contentDbContext);
var result = await service.ListSubjects(release.Id);
var subjects = result.AssertRight();
Assert.Empty(subjects);
}
}
public void BatchesPath()
{
var releaseFile = new ReleaseFile
{
File = new File
{
Id = Guid.NewGuid(),
RootPath = Guid.NewGuid(),
Filename = "data.csv",
Type = FileType.Data
}
};
Assert.Equal(releaseFile.File.BatchesPath(), releaseFile.BatchesPath());
}
public void Path()
{
var releaseFile = new ReleaseFile
{
File = new File
{
Id = Guid.NewGuid(),
RootPath = Guid.NewGuid(),
Filename = "ancillary.pdf",
Type = Ancillary
}
};
Assert.Equal(releaseFile.File.Path(), releaseFile.Path());
}
public async Task <File> Create(
Guid releaseId,
Guid subjectId,
string filename,
FileType type,
Guid createdById,
string name = null,
File replacingFile = null,
File source = null)
{
if (!SupportedFileTypes.Contains(type))
{
throw new ArgumentOutOfRangeException(nameof(type), type, "Cannot create file for file type");
}
if (type == Metadata && replacingFile != null)
{
throw new ArgumentException("replacingFile only used with Files of type Data, not Metadata.");
}
var releaseFile = new ReleaseFile
{
ReleaseId = releaseId,
Name = name,
File = new File
{
Created = DateTime.UtcNow,
CreatedById = createdById,
RootPath = releaseId,
SubjectId = subjectId,
Filename = filename,
Type = type,
Replacing = replacingFile,
Source = source
}
};
var created = (await _contentDbContext.ReleaseFiles.AddAsync(releaseFile)).Entity;
if (replacingFile != null)
{
_contentDbContext.Update(replacingFile);
replacingFile.ReplacedBy = releaseFile.File;
}
await _contentDbContext.SaveChangesAsync();
return(created.File);
}
private async Task <FileInfo> GetReleaseFileInfo(ReleaseFile releaseFile)
{
var blobExists = await _blobStorageService.CheckBlobExists(
PrivateReleaseFiles,
releaseFile.Path()
);
if (!blobExists)
{
return(releaseFile.ToFileInfoNotFound());
}
var blob = await _blobStorageService.GetBlob(PrivateReleaseFiles, releaseFile.Path());
return(releaseFile.ToFileInfo(blob));
}
static void upload(ReleaseService rs, FileInfo fi, string release, string checkfile)
{
if (isNewer(checkfile, fi.FullName))
{
Console.WriteLine("Uploading " + release + "...");
ReleaseFile f = new ReleaseFile();
f.Name = fi.Name;
f.MimeType = "application/octet-stream";
f.FileName = fi.Name;
f.FileType = ReleaseFileType.RuntimeBinary;
f.FileData = File.ReadAllBytes(fi.FullName);
List <ReleaseFile> files = new List <ReleaseFile>();
files.Add(f);
rs.UploadReleaseFiles("Z3", release, files, f.Name);
}
}
public void PublicPath_ReleaseFile()
{
var release = new Release
{
Publication = new Publication
{
Slug = PublicationSlug
},
Slug = ReleaseSlug
};
var releaseFile = new ReleaseFile
{
Release = release,
File = _file
};
Assert.Equal(_file.PublicPath(release), releaseFile.PublicPath());
}
public async Task GetReleaseCoverArtShouldGetReleaseCoverArt()
{
var release = new Release();
var releaseFile = new ReleaseFile
{
ReleaseId = release.Id,
FileType = FileType.Image,
IsPreview = true
};
await this.dbContext.ReleaseFiles.AddAsync(releaseFile);
await this.dbContext.SaveChangesAsync();
var coverArt = await this.releaseFilesService.GetReleaseCoverArt <ReleaseFileResourceModel>(release.Id);
Assert.NotNull(coverArt);
}
/// <remarks/>
public System.IAsyncResult BeginUploadTheReleaseFiles(string projectName, string releaseName, ReleaseFile[] files, string recommendedFileName, string username, string password, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("UploadTheReleaseFiles", new object[] {
projectName,
releaseName,
files,
recommendedFileName,
username,
password}, callback, asyncState);
}
public void UploadTheReleaseFiles(string projectName, string releaseName, ReleaseFile[] files, string recommendedFileName, string username, string password)
{
this.Invoke("UploadTheReleaseFiles", new object[] {
projectName,
releaseName,
files,
recommendedFileName,
username,
password});
}
/// <remarks/>
public void UploadTheReleaseFilesAsync(string projectName, string releaseName, ReleaseFile[] files, string recommendedFileName, string username, string password)
{
this.UploadTheReleaseFilesAsync(projectName, releaseName, files, recommendedFileName, username, password, null);
}
/// <remarks/>
public void UploadTheReleaseFilesAsync(string projectName, string releaseName, ReleaseFile[] files, string recommendedFileName, string username, string password, object userState)
{
if ((this.UploadTheReleaseFilesOperationCompleted == null)) {
this.UploadTheReleaseFilesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUploadTheReleaseFilesOperationCompleted);
}
this.InvokeAsync("UploadTheReleaseFiles", new object[] {
projectName,
releaseName,
files,
recommendedFileName,
username,
password}, this.UploadTheReleaseFilesOperationCompleted, userState);
}
