public void WhenLoadReferencesAreLoaded()
{
// Arrange
var adaptersMock = Mock.Create <IReferenceAdapters>();
var albumAdapterMock = Mock.Create <IDataAdapter <Album> >();
var artistAdapterMock = Mock.Create <IDataAdapter <Artist> >();
var titleAdapterMock = Mock.Create <IDataAdapter <Title> >();
var genreAdapterMock = Mock.Create <IDataAdapter <Genre> >();
var yearAdapterMock = Mock.Create <IDataAdapter <Year> >();
Mock.Arrange(() => adaptersMock.AlbumAdapter).Returns(albumAdapterMock);
Mock.Arrange(() => adaptersMock.ArtistAdapter).Returns(artistAdapterMock);
Mock.Arrange(() => adaptersMock.TitleAdapter).Returns(titleAdapterMock);
Mock.Arrange(() => adaptersMock.GenreAdapter).Returns(genreAdapterMock);
Mock.Arrange(() => adaptersMock.YearAdapter).Returns(yearAdapterMock);
var target = new StorableTaggedFile();
// Act
target.LoadReferences(adaptersMock);
// Assert(s)...
Mock.Assert(() => albumAdapterMock.GetFirst(Arg.IsAny <Expression <Func <Album, bool> > >()));
Mock.Assert(() => artistAdapterMock.GetFirst(Arg.IsAny <Expression <Func <Artist, bool> > >()));
Mock.Assert(() => titleAdapterMock.GetFirst(Arg.IsAny <Expression <Func <Title, bool> > >()));
Mock.Assert(() => genreAdapterMock.GetFirst(Arg.IsAny <Expression <Func <Genre, bool> > >()));
Mock.Assert(() => yearAdapterMock.GetFirst(Arg.IsAny <Expression <Func <Year, bool> > >()));
}
/// <summary>
/// Adds the file.
/// </summary>
/// <param name="file">The file.</param>
public void AddFile(StorableTaggedFile file)
{
file.LoadReferences(referenceAdapters);
lock (files)
files.Add(file);
publicTransport.ApplicationEventBus.Publish(new PlaylistUpdatedEvent());
}
/// <summary>
/// Plays this instance.
/// </summary>
/// <param name="file"></param>
public virtual void Play(StorableTaggedFile file)
{
file.Guard("file");
var oldCurrent = CurrentTrack;
var newChannel = new TrackContainer(player, file);
try
{
newChannel.Preload();
}
catch (Exception e)
{
newChannel.Dispose();
LogException(e, MethodBase.GetCurrentMethod());
LogWarning("File Was: {0}", file.Filename);
return;
}
SwapChannels(newChannel);
if (null != oldCurrent)
{
PushContainer(oldCurrent);
}
var index = playlistService.Files.IndexOf(file);
if (index < 0)
{
return;
}
playlistService.SetPlaylistIndex(file);
ReBuffer();
}
/// <summary>
/// Creates the channel.
/// </summary>
/// <param name="file">The file.</param>
/// <returns></returns>
public ITrack CreateChannel(StorableTaggedFile file)
{
var fileName = file.Filename;
var sound = CreateSoundFromFile(fileName);
return(new FMODTrack(sound, fmodSystem, fileName));
}
/// <summary>
/// Stores the specified value.
/// </summary>
/// <param name="value">The value.</param>
public void Store(StorableTaggedFile value)
{
//StorableTaggedFile file;
//if ((file = value) == null)
// file = StorableTaggedFile.Copy(value);
fileStorer.Save(value);
}
/// <summary>
/// Creates the channel.
/// </summary>
/// <param name="file">The file.</param>
/// <returns></returns>
public ITrack CreateChannel(StorableTaggedFile file)
{
var fileName = file.Filename;
var stream = CreateInput(fileName);
return(new NAudioTrack(this, mixerStream, stream, fileName));
}
/// <summary>
/// Initializes a new instance of the <see cref="TrackContainer" /> class.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="file">The file.</param>
public TrackContainer(IAudioPlayer player, StorableTaggedFile file)
{
player.Guard("player");
file.Guard("file");
this.player = player;
File = file;
}
private void OnFileDoubleClicked(StorableTaggedFile obj)
{
if (null == obj)
{
return;
}
publicTransport.CommandBus.Publish(new AddFilesCommand(new[] { obj }));
publicTransport.CommandBus.Publish(new PlayFileCommand(obj));
}
public void WhenFileExistsItIsUpdated()
{
// Arrange
IDataAdapter <Album> albumAdapterMock;
IDataAdapter <Genre> genreAdapterMock;
IDataAdapter <Artist> artistAdapterMock;
IDataAdapter <Title> titleAdapterMock;
IDataAdapter <Year> yearAdapterMock;
var adaptersMock = TestHelper.CreateReferenceAdaptersMock(
out albumAdapterMock,
out artistAdapterMock,
out titleAdapterMock,
out genreAdapterMock,
out yearAdapterMock);
var fileAdapterMock = Mock.Create <IDataAdapter <StorableTaggedFile> >();
const string fileName = "Filename";
var existingId = StorableTaggedFile.GenerateLowerCaseId(fileName, StorableTaggedFile.FilenameNamespace);
var existingFile = new StorableTaggedFile {
Filename = fileName
};
Mock.Arrange(() => fileAdapterMock.GetFirstById(existingId)).Returns(existingFile);
var file = new StorableTaggedFile
{
Album = new Album {
Name = "Album"
},
Artist = new Artist {
Name = "Artist"
},
Comment = "Blah",
Filename = fileName,
Genre = new Genre {
Name = "Genre"
},
Title = new Title {
Name = "Title"
},
TrackNo = 50000,
Year = new Year {
Name = "Year"
},
Id = existingId,
};
var target = new Builder <TaggedFilePersister>().With(adaptersMock).With(fileAdapterMock).Build();
target.Save(file);
Assert.AreEqual(file.AlbumId, existingFile.AlbumId);
Assert.AreEqual(file.ArtistId, existingFile.ArtistId);
Assert.AreEqual(file.Comment, existingFile.Comment);
Assert.AreEqual(file.Filename, existingFile.Filename);
Assert.AreEqual(file.GenreId, existingFile.GenreId);
Assert.AreEqual(file.TitleId, existingFile.TitleId);
Assert.AreEqual(file.TrackNo, existingFile.TrackNo);
Assert.AreEqual(file.YearId, existingFile.YearId);
}
public void WhenLazyLoadReferencesLazyFileReturned()
{
// Arrange
var adaptersMock = Mock.Create <IReferenceAdapters>();
var target = new StorableTaggedFile();
// Act
var result = target.LazyLoadReferences(adaptersMock);
// Assert
Assert.IsInstanceOf <LazyLoadedTaggedFile>(result);
}
public void WhenArtistTitleNullLoadMeReturned()
{
// Arrange
var target = new StorableTaggedFile();
const string expected = "LOADME!";
// Act
var result = target.ToString();
// Assert
Assert.AreEqual(expected, result);
}
public ITrack CreateChannel(StorableTaggedFile file)
{
try
{
var player = GetPlayer(file.StorageType);
return(player.CreateChannel(file));
}
catch (KeyNotFoundException e)
{
throw new FormatException(
string.Format("Could not find player for the file type {0}", file.StorageType), e);
}
}
public void WhenStorePersisterUsed()
{
// Arrange
var persister = Mock.Create <IDataPersister <StorableTaggedFile> >();
var target = new Builder <LibraryManagerService>().With(persister).Build();
var expected = new StorableTaggedFile();
// Act
target.Store(expected);
// Assert
Mock.Assert(() => persister.Save(expected));
}
protected virtual void SetActive(StorableTaggedFile file, double offset)
{
var container = GetContainer(file);
if (null == container)
{
return;
}
CurrentTrack = container;
container.Seek(offset);
NotifyNewTrack(container);
SendProgress();
}
private void SetPlayingFile(StorableTaggedFile file)
{
if (null != playingFile)
{
playingFile.IsPlaying = false;
}
SelectedFile = Files.Find(x => x.File == file);
playingFile = SelectedFile;
if (null == playingFile)
{
return;
}
playingFile.IsPlaying = true;
}
/// <summary>
/// Sets the index of the playlist.
/// </summary>
/// <param name="from">From.</param>
public void SetPlaylistIndex(StorableTaggedFile from)
{
lock (files)
{
if (null == from)
{
currentIndex = -1;
}
else
{
currentIndex = files.IndexOf(from) + 1;
}
}
}
private TrackContainer GetContainer(StorableTaggedFile file)
{
var channel = new TrackContainer(player, file);
try
{
channel.Preload();
}
catch
{
return(null);
}
return(channel);
}
public void WhenSaveReferencesSaved()
{
// Arrange
IDataAdapter <Album> albumAdapterMock;
IDataAdapter <Genre> genreAdapterMock;
IDataAdapter <Artist> artistAdapterMock;
IDataAdapter <Title> titleAdapterMock;
IDataAdapter <Year> yearAdapterMock;
var adaptersMock = TestHelper.CreateReferenceAdaptersMock(
out albumAdapterMock,
out artistAdapterMock,
out titleAdapterMock,
out genreAdapterMock,
out yearAdapterMock);
var fileAdapterMock = Mock.Create <IDataAdapter <StorableTaggedFile> >();
var file = new StorableTaggedFile
{
Album = new Album(),
Artist = new Artist(),
Comment = "Blah",
Filename = "Blah2",
Genre = new Genre(),
Title = new Title(),
TrackNo = 50000,
Year = new Year(),
};
var target = new Builder <TaggedFilePersister>().With(adaptersMock).With(fileAdapterMock).Build();
// Act
target.Save(file);
// Assert
// ReSharper disable ImplicitlyCapturedClosure
Mock.Assert(() => albumAdapterMock.Save(file.Album));
Mock.Assert(() => genreAdapterMock.Save(file.Genre));
Mock.Assert(() => artistAdapterMock.Save(file.Artist));
Mock.Assert(() => titleAdapterMock.Save(file.Title));
Mock.Assert(() => yearAdapterMock.Save(file.Year));
Mock.Assert(() => fileAdapterMock.Save(file));
// ReSharper restore ImplicitlyCapturedClosure
}
public void WhenInitializedIdsCopied()
{
var original = new StorableTaggedFile
{
AlbumId = Guid.NewGuid(),
GenreId = Guid.NewGuid(),
ArtistId = Guid.NewGuid(),
TitleId = Guid.NewGuid(),
YearId = Guid.NewGuid(),
Id = Guid.NewGuid(),
};
var target = new Builder <LazyLoadedTaggedFile>().With(original).Build();
Assert.AreEqual(original.AlbumId, target.AlbumId);
Assert.AreEqual(original.GenreId, target.GenreId);
Assert.AreEqual(original.ArtistId, target.ArtistId);
Assert.AreEqual(original.TitleId, target.TitleId);
Assert.AreEqual(original.YearId, target.YearId);
Assert.AreEqual(original.Id, target.Id);
}
/// <summary>
/// Creates the channel.
/// </summary>
/// <param name="file">The file.</param>
/// <returns></returns>
public ITrack CreateChannel(StorableTaggedFile file)
{
var fileName = file.Filename;
var channelHandle = Bassh.BASS_StreamCreateFile(fileName, 0, 0, BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE);
Bassh.BASS_ChannelUpdate(channelHandle, 0);
Bassh.BASS_ChannelSetAttribute(channelHandle, BASSAttribute.BASS_ATTRIB_SRC, 2);
Debug.WriteLine(Bassh.BASS_ChannelGetInfo(channelHandle));
if (0 == channelHandle)
{
throw new InvalidOperationException("Unable to create stream");
}
if (BassMix.BASS_Mixer_StreamAddChannel(mixerHandle, channelHandle,
BASSFlag.BASS_MIXER_PAUSE | BASSFlag.BASS_MIXER_BUFFER | BASSFlag.BASS_MIXER_NORAMPIN))
{
return(new BassTrack(channelHandle, mixerHandle, fileName));
}
Trace.WriteLine(Bassh.BASS_ErrorGetCode());
throw new InvalidOperationException("Unable to add channel to mixer.");
}
public void WhenOtherFieldsRequestedReferenceAdaptersUsed()
{
IDataAdapter <Album> albumAdapterMock;
IDataAdapter <Genre> genreAdapterMock;
IDataAdapter <Artist> artistAdapterMock;
IDataAdapter <Title> titleAdapterMock;
IDataAdapter <Year> yearAdapterMock;
var adaptersMock = TestHelper.CreateReferenceAdaptersMock(
out albumAdapterMock,
out artistAdapterMock,
out titleAdapterMock,
out genreAdapterMock,
out yearAdapterMock);
var original = new StorableTaggedFile
{
AlbumId = Guid.NewGuid(),
GenreId = Guid.NewGuid(),
ArtistId = Guid.NewGuid(),
TitleId = Guid.NewGuid(),
YearId = Guid.NewGuid(),
Id = Guid.NewGuid(),
};
var target = new Builder <LazyLoadedTaggedFile>().With(original).With(adaptersMock).Build();
#pragma warning disable 219
// ReSharper disable RedundantAssignment
// ReSharper disable ImplicitlyCapturedClosure
object stuff = target.Album;
Mock.Assert(() => albumAdapterMock.GetFirstById(original.AlbumId));
stuff = target.Genre;
Mock.Assert(() => genreAdapterMock.GetFirstById(original.GenreId));
stuff = target.Artist;
Mock.Assert(() => artistAdapterMock.GetFirstById(original.ArtistId));
stuff = target.Title;
Mock.Assert(() => titleAdapterMock.GetFirstById(original.TitleId));
stuff = target.Year;
Mock.Assert(() => yearAdapterMock.GetFirstById(original.YearId));
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper restore RedundantAssignment
#pragma warning restore 219
}
public void ToStringReturnsArtistTitle()
{
// Arrange
const string expectedArtist = "Artist";
const string expectedTitle = "Title";
const string expectedString = expectedArtist + " - " + expectedTitle;
var target = new StorableTaggedFile
{
Artist = new Artist {
Name = expectedArtist
},
Title = new Title {
Name = expectedTitle
}
};
// Act
var result = target.ToString();
// Assert
Assert.AreEqual(expectedString, result);
}
/// <summary>
/// Searches the view on play file.
/// </summary>
/// <param name="storableTaggedFile">The storable tagged file.</param>
private void SearchViewOnPlayFile(StorableTaggedFile storableTaggedFile)
{
publicTransport.CommandBus.Publish(new PlayFileCommand(storableTaggedFile));
}
/// <summary>
/// Searches the view on play file.
/// </summary>
/// <param name="storableTaggedFile">The storable tagged file.</param>
private void SearchViewOnPlayFile(StorableTaggedFile storableTaggedFile)
{
playerService.Play(storableTaggedFile);
}
/// <summary>
/// Removes the file.
/// </summary>
/// <param name="file">The file.</param>
public void RemoveFile(StorableTaggedFile file)
{
lock (files)
files.Remove(file);
publicTransport.ApplicationEventBus.Publish(new PlaylistUpdatedEvent());
}
public FileItem(StorableTaggedFile file)
{
this.file = file;
}
/// <summary>
/// Initializes a new instance of the <see cref="TrackChangedEvent" /> class.
/// </summary>
/// <param name="file">The file.</param>
/// <param name="songLength">Length of the song.</param>
public TrackChangedEvent(StorableTaggedFile file, TimeSpan songLength)
{
File = file;
SongLength = songLength;
}
public void WhenSaveReferencesQueried()
{
// Arrange
IDataAdapter <Album> albumAdapterMock;
IDataAdapter <Genre> genreAdapterMock;
IDataAdapter <Artist> artistAdapterMock;
IDataAdapter <Title> titleAdapterMock;
IDataAdapter <Year> yearAdapterMock;
var adaptersMock = TestHelper.CreateReferenceAdaptersMock(
out albumAdapterMock,
out artistAdapterMock,
out titleAdapterMock,
out genreAdapterMock,
out yearAdapterMock);
var fileAdapterMock = Mock.Create <IDataAdapter <StorableTaggedFile> >();
var configManagerMock = Mock.Create <IConfigurationManager>();
Mock.Arrange(() => configManagerMock.GetValue(Arg.IsAny <string>(), Arg.IsAny <int>(), Arg.IsAny <string>()))
.Returns(Mock.Create <IConfigurableValue <int> >());
var file = new StorableTaggedFile
{
Album = new Album {
Name = "Album"
},
Artist = new Artist {
Name = "Artist"
},
Comment = "Blah",
Filename = "Blah2",
Genre = new Genre {
Name = "Genre"
},
Title = new Title {
Name = "Title"
},
TrackNo = 50000,
Year = new Year {
Name = "Year"
},
};
var target = new Builder <TaggedFilePersister>().With(adaptersMock).With(fileAdapterMock).With(configManagerMock).Build();
// Act
target.Save(file);
// Assert
// ReSharper disable ImplicitlyCapturedClosure
Mock.Assert(
() =>
albumAdapterMock.GetFirstById(StorableTaggedFile.GenerateLowerCaseId(file.Album.Name, StorableTaggedFile.AlbumNamespace)));
Mock.Assert(
() =>
genreAdapterMock.GetFirstById(StorableTaggedFile.GenerateLowerCaseId(file.Genre.Name, StorableTaggedFile.GenreNamespace)));
Mock.Assert(
() =>
artistAdapterMock.GetFirstById(StorableTaggedFile.GenerateLowerCaseId(file.Artist.Name, StorableTaggedFile.ArtistNamespace)));
Mock.Assert(
() =>
titleAdapterMock.GetFirstById(StorableTaggedFile.GenerateLowerCaseId(file.Title.Name, StorableTaggedFile.TitleNamespace)));
Mock.Assert(
() =>
yearAdapterMock.GetFirstById(StorableTaggedFile.GenerateLowerCaseId(file.Year.Name, StorableTaggedFile.YearNamespace)));
// ReSharper restore ImplicitlyCapturedClosure
}
public ITrack CreateChannel(StorableTaggedFile file)
{
return(null);
}
private void ChangeTrack(StorableTaggedFile newTrack)
{
NowPlaying = newTrack;
}
