/// <summary>
/// Main search method.
/// </summary>
/// <returns>Array of search results.</returns>
public List <ISearchEngineResultItem> Search()
{
int maxNoOfResults = Int32.Parse(MaxNoOfResults);
if (ProviderAttributes[MaxNoOfResults] != null)
{
Int32.TryParse(ProviderAttributes[MaxNoOfResults], out maxNoOfResults);
}
CalendarEventArgs args = new CalendarEventArgs();
args.SearchPhrase = SearchPhrase;
args.MaximumNumberOfItems = maxNoOfResults;
EntityCollection <CalendarEventEntity> collection = DependencyInjectionFactory.Resolve <ICalendarEventBLL>().
GetCalendarEvents(args);
List <ISearchEngineResultItem> results = new List <ISearchEngineResultItem>();
foreach (CalendarEventEntity CalEvent in collection)
{
CalendarEventSearchResultItem item = InitializeItem(CalEvent);
results.Add(item);
}
return(results);
}
public void BuildStructureWithDifferentConnectionNameTest()
{
// arrange
var di = DependencyInjectionFactory.ConfigureDependencyInjection();
var clientConfig = di.GetService <IClientConfig>();
if (!clientConfig.IsAssigned())
{
throw new Exception("clientconfig not returned by dependency injection");
}
clientConfig.DefaultDatabase = "SchemaDatabaseDevelopment";
var client = new SqlClient(new SqlClientRepository(clientConfig));
IDatabaseStructure target = new DatabaseStructure(client);
// act
target.BuildStructure();
// assert
target.Tables.Should().HaveCount(8); // TestClassGenerator heeft nu 6 tabellen
target.Tables.First(x => x.Name == "Test6").PrimaryKey.Should().Be("Test6Id");
}
public async Task Playlists_ShouldLoad()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var dummyPlaylists = new List <Playlist>
{
container.CreatePlaylist(_context.CreateModelPlaylist()),
};
var repository = ContainerContextExtensions.CreateRepository();
repository.GetPlaylistsAsync().ReturnsForAnyArgs(dummyPlaylists);
container.UseInstance(repository);
var playlists = (Playlists)container.Resolve <IPlaylistsViewModel>();
repository.ClearReceivedCalls();
await playlists.LoadAsync().ConfigureAwait(false);
await repository.Received(1).GetPlaylistsAsync().ConfigureAwait(false);
repository.Received(1).Dispose();
Assert.AreEqual(dummyPlaylists[0], playlists.SelectedItem);
Assert.AreEqual(1, playlists.Count);
}
public async Task Playlist_ShouldRunConstructorWithoutErrors()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var model = _context.CreateModelPlaylist();
var playlist = container.CreatePlaylist(model);
Assert.AreEqual(_context.FullyQualifiedTestClassName, playlist.CreatedBy);
Assert.AreEqual(_context.FullyQualifiedTestClassName, playlist.UpdatedBy);
Assert.AreEqual(4, playlist.Count);
Assert.AreEqual($"Description for {_context.FullyQualifiedTestClassName} Playlist", playlist.Description);
Assert.AreEqual(false, playlist.HasErrors);
Assert.AreEqual(1, playlist.Id);
Assert.AreEqual(false, playlist.IsBusy);
Assert.AreEqual(false, playlist.IsChanged);
Assert.AreEqual(false, playlist.IsDeleted);
Assert.AreEqual(false, playlist.IsNew);
Assert.AreEqual(false, playlist.IsSelected);
Assert.AreEqual(false, playlist.IsShuffeling);
Assert.AreEqual(4, playlist.Items.Count);
Assert.AreEqual(model, playlist.Model);
Assert.AreEqual(PrivacyStatus.None, playlist.PrivacyStatus);
Assert.AreEqual(RepeatMode.None, playlist.RepeatMode);
Assert.AreEqual(playlist[0], playlist.SelectedItem);
Assert.AreEqual(1, playlist.Sequence);
Assert.AreEqual($"Title for {_context.FullyQualifiedTestClassName} Playlist", playlist.Title);
Assert.IsNotNull(playlist.View);
Assert.IsNotNull(playlist.ClearCommand);
Assert.IsNotNull(playlist.LoadFromFileCommand);
Assert.IsNotNull(playlist.LoadFromFolderCommand);
Assert.IsNotNull(playlist.LoadFromUrlCommand);
Assert.IsNotNull(playlist.RemoveCommand);
Assert.IsNotNull(playlist.RemoveRangeCommand);
}
private void HandleLogInfo(LogInfo info)
{
try
{
info.Request = DependencyInjectionFactory.TryToResolveIRequest()?.UserRequest;
LogToDbException(info);
}
catch (Exception ex)
{
try
{
LogToFileException(info);
var log = new LogInfo();
log.OccuredException = ex;
log.CustomMessage = "خطا در هنگام ثبت لاگ در دیتابیس!";
LogToFileException(log);
}
catch
{
}
}
if (info.RaiseThrowException)
{
throw info.OccuredException;
}
}
public void When_GetTypedCommaFields_executed_on_table_Should_return_a_string_with_all_ColumnNames_concatenated()
{
// arrange
var di = DependencyInjectionFactory.ConfigureDependencyInjection();
var clientConfig = di.GetService <IClientConfig>();
if (!clientConfig.IsAssigned())
{
throw new Exception("clientconfig not returned by dependency injection");
}
clientConfig.DefaultDatabase = "SchemaDatabaseDevelopment";
var client = new SqlClient(new SqlClientRepository(clientConfig));
IDatabaseStructure target = new DatabaseStructure(client);
target.BuildStructure();
var table = target.Tables.First(x => x.Name == "Test5");
var columnNameList = new List <string> {
"naam", "Omschrijving"
};
// act
var columnString = table.ColumnDataItems.GetFieldNamesAsParameters(columnNameList);
// assert
columnString.Should().Be("string naam, string omschrijving");
}
public void When_VerifyDatabaseServer_With_valid_database_Should_return_Ok()
{
// Arrange
var di = DependencyInjectionFactory.ConfigureDependencyInjection();
var clientConfig = di.GetService <IClientConfig>();
if (!clientConfig.IsAssigned())
{
throw new Exception("clientconfig not returned by dependency injection");
}
clientConfig.DefaultDatabase = "TestClassGenerator";
var connection = clientConfig.GetConfigConnection();
if (!connection.IsAssigned())
{
throw new Exception("connection not returned by configuration");
}
var config = ConnectionManagement.SetDatabaseSecurityInMemory(connection.UserName, connection.Password, connection.ConnectionName);
var databaseProviderFactory = new DatabaseProviderFactory(config.GetSection);
var database = databaseProviderFactory.Create("TestClassGenerator");
// Act
var result = SqlServerCheck.VerifyDatabaseServer(database, 1000);
// Assert
result.Should().BeTrue();
}
public async Task Playlist_ShouldRunPrevious()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var playlist = container.CreatePlaylist(_context.CreateModelPlaylist());
var messenger = container.Resolve <IMessenger>();
messenger.Publish(new PlayingMediaItemMessage(this, playlist[0], playlist.Id));
messenger.Publish(new PlayingMediaItemMessage(this, playlist[1], playlist.Id));
messenger.Publish(new PlayingMediaItemMessage(this, playlist[2], playlist.Id));
var previous = playlist.Previous();
Assert.AreEqual(playlist[2], previous);
Assert.AreEqual(true, previous.IsSelected);
Assert.AreEqual(1, playlist.Items.Where(p => p.IsSelected).Count());
previous = playlist.Previous();
Assert.AreEqual(playlist[1], previous);
Assert.AreEqual(true, previous.IsSelected);
Assert.AreEqual(1, playlist.Items.Where(p => p.IsSelected).Count());
previous = playlist.Previous();
Assert.AreEqual(playlist[0], previous);
Assert.AreEqual(true, previous.IsSelected);
Assert.AreEqual(1, playlist.Items.Where(p => p.IsSelected).Count());
previous = playlist.Previous();
Assert.AreEqual(null, previous);
Assert.AreEqual(0, playlist.Items.Where(p => p.IsSelected).Count());
previous = playlist.Previous();
Assert.AreEqual(null, previous);
Assert.AreEqual(0, playlist.Items.Where(p => p.IsSelected).Count());
}
public void When_TableExists_is_executed_and_table_does_notexists_Should_return_false()
{
// arrange
var di = DependencyInjectionFactory.ConfigureDependencyInjection();
var clientConfig = di.GetService <IClientConfig>();
if (!clientConfig.IsAssigned())
{
throw new Exception("clientconfig not returned by dependency injection");
}
clientConfig.DefaultDatabase = "TestClassGenerator";
var client = new SqlClient(new SqlClientRepository(clientConfig));
IDatabaseStructure target = new DatabaseStructure(client);
target.BuildStructure();
// act
var tableExists = client.TableExists("Test666");
// assert
tableExists.Should().BeFalse();
}
public void When_VerifyDatabaseServer_With_invalid_database_Should_return_DoesNotExist()
{
// Arrange
var di = DependencyInjectionFactory.ConfigureDependencyInjection();
var clientConfig = di.GetService <IClientConfig>();
if (!clientConfig.IsAssigned())
{
throw new Exception("clientconfig not returned by dependency injection");
}
clientConfig.DefaultDatabase = "TestDatabase";
var connection = clientConfig.GetConfigConnection();
if (!connection.IsAssigned())
{
throw new Exception("connection not returned by configuration");
}
var config = ConnectionManagement.SetDatabaseSecurityInMemory(connection.UserName, connection.Password, connection.ConnectionName);
var databaseProviderFactory = new DatabaseProviderFactory(config.GetSection);
var database = databaseProviderFactory.Create("TestDatabase");
// Act
Action action = () => SqlServerCheck.VerifyDatabaseServer(database, 1000);
// Assert
action.Should().Throw <SqlClientException>().WithMessage("Database TestDatabase does not exist");
}
public async Task Playlist_ShouldAddItemsFromUrlDialog()
{
var tokenSource = new CancellationTokenSource(1000);
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var mediaItems = new[]
{
container.CreateMediaItem(new MediaItemModel()),
container.CreateMediaItem(new MediaItemModel()),
container.CreateMediaItem(new MediaItemModel()),
};
var dialogViewModel = Substitute.For <IDialogViewModel>();
dialogViewModel.ShowUrlParseDialog(NSubstitute.Arg.Any <CancellationToken>()).Returns((mediaItems));
container.UseInstance(typeof(IDialogViewModel), dialogViewModel, IfAlreadyRegistered: IfAlreadyRegistered.Replace);
var playlist = container.CreatePlaylist(_context.CreateModelPlaylist());
foreach (var item in mediaItems)
{
Assert.AreEqual(false, playlist.Items.Contains(item));
}
await playlist.LoadFromUrlCommand.ExecuteAsync(tokenSource.Token).ConfigureAwait(false);
foreach (var item in mediaItems)
{
Assert.AreEqual(true, playlist.Items.Contains(item));
}
}
public static bool UpdateDCUser()
{
var userProfileService = DependencyInjectionFactory.CreateInjectionInstance <IUserProfileService>();
var domainAuthenticationService = DependencyInjectionFactory.CreateInjectionInstance <IDomainAuthenticationService>();
//user hayi az DC ke login kardand vali password e DC anha taghir karde ra migirad
//meghdare DCPassword ra dar cache null mikonad ta user az halate motabr boodan kharej shavad
var DCUserProfileList = userProfileService.All()
.Where(profile =>
profile.IsDCUser && !string.IsNullOrEmpty(profile.DCPassword)).ToList()
.Select(profile =>
{
var info = new UserProfile()
{
UserName = profile.UserName,
Password = profile.DCPassword
};
//if (!domainAuthenticationService.ValidateUser(info))
if (!userProfileService.ValidateUser(info))
{
profile.DCPassword = null;
}
return(profile);
});
return(DCUserProfileList.Count() > 0);
}
public async Task Playlist_ShouldThrowAddForNull()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var playlist = CreatePlaylist(CreateModelPlaylist(), container);
Assert.ThrowsException <ArgumentNullException>(() => playlist.Add(null));
}
public async Task Playlist_ShouldThrowRemoveRangeForNull()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var playlist = container.CreatePlaylist(_context.CreateModelPlaylist());
Assert.ThrowsException <ArgumentNullException>(() => playlist.RemoveRange(null));
}
public async Task ResolveMessengerTest()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var messenger = Substitute.For <IMessenger>();
container.UseInstance(typeof(IMessenger), messenger, IfAlreadyRegistered: IfAlreadyRegistered.Replace);
Assert.AreEqual(messenger, container.Resolve <IMessenger>());
}
public void When_DependecyInjection_is_used_With_DbMenu_Should_return_DatabaseStructure_of_DbMenu(string param, string delim, string value)
{
// arrange
var dependencyProvider = DependencyInjectionFactory.ConfigureDependencyInjection($"{param}{delim}{value}");
// act
var target = dependencyProvider.GetService <IDatabaseStructure>();
// assert
target.Should().NotBeNull();
target.Should().BeOfType <DatabaseStructure>();
}
public void When_DependecyInjection_is_used_should_return_DatabaseStructure_Of_defaultDb()
{
// arrange
var dependencyProvider = DependencyInjectionFactory.ConfigureDependencyInjection();
// act
var target = dependencyProvider.GetService <IDatabaseStructure>();
// assert
target.Should().NotBeNull();
target.Should().BeOfType <DatabaseStructure>();
}
public async Task Playlist_ShouldRemove()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var playlist = container.CreatePlaylist(_context.CreateModelPlaylist());
Assert.AreEqual(4, playlist.Count);
playlist.Remove(playlist[0]);
Assert.AreEqual(3, playlist.Count);
}
public async Task Playlist_ShouldRunClear()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var playlist = CreatePlaylist(CreateModelPlaylist(), container);
Assert.AreEqual(4, playlist.Count);
playlist.Clear();
Assert.AreEqual(0, playlist.Count);
}
public async Task ResolveManyLoadablesAsList()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var factory = Substitute.For <IWavePlayerFactory>();
container.UseInstance(factory);
var loadables = container.ResolveMany <ILoadableViewModel>().ToList();
Assert.IsNotNull(loadables);
Assert.IsTrue(loadables?.Count > 3, $"Only {loadables.Count} instance(s) found");
}
public async Task Playlist_ShouldRunNext()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var playlist = CreatePlaylist(CreateModelPlaylist(), container);
playlist.RepeatMode = RepeatMode.None;
var mediaItem = playlist.Next();
Assert.IsNotNull(mediaItem);
Assert.AreEqual(playlist[1], mediaItem);
Assert.AreNotEqual(playlist.SelectedItem, mediaItem);
}
public async Task Playlist_ShouldAdd()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var mediaItem = container.CreateMediaItem(_context.CreateModelMediaItem());
var playlist = container.CreatePlaylist(_context.CreateModelPlaylist());
Assert.AreEqual(4, playlist.Count);
playlist.Add(mediaItem);
Assert.AreEqual(5, playlist.Count);
}
public async Task Playlist_ShouldHandleRemoveRangeForEmptyCollection()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var playlist = container.CreatePlaylist(_context.CreateModelPlaylist());
var mediaItems = new List <MediaItem>();
Assert.AreEqual(4, playlist.Count);
playlist.RemoveRange(mediaItems);
Assert.AreEqual(4, playlist.Count);
}
public void When_DependecyInjection_is_used_should_have_UseEnvironmentSetting_set_to_true()
{
// arrange
var dependencyProvider = DependencyInjectionFactory.ConfigureDependencyInjection();
// act
var target = dependencyProvider.GetService <IClientConfig>();
// assert
target.Should().NotBeNull();
target.Should().BeOfType <ClientConfig>();
target?.UseEnvironmentSetting.Should().BeTrue();
}
public async Task Playlist_ShouldRunNextWithRepeatModeNone()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var playlist = container.CreatePlaylist(_context.CreateModelPlaylist());
playlist.RepeatMode = RepeatMode.None;
playlist.SelectedItem = playlist[3];
var mediaItem = playlist.Next();
Assert.IsNull(mediaItem);
}
public void When_DependecyInjection_is_used_should_return_commandlinearguments()
{
// arrange
var dependencyProvider = DependencyInjectionFactory.ConfigureDependencyInjection(@"--ConfigFileFolder=some\location\");
// act
var target = dependencyProvider.GetService <IClientConfig>();
// assert
target.Should().NotBeNull();
target.Should().BeOfType <ClientConfig>();
target?.ConfigFileFolder.Should().Be(@"some\location\");
}
public async Task Playlist_ShouldRunNextWithRepeatModeSingleWhileShuffeling()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var playlist = container.CreatePlaylist(_context.CreateModelPlaylist());
playlist.RepeatMode = RepeatMode.Single;
playlist.IsShuffeling = true;
var mediaItem = playlist.Next();
Assert.IsNotNull(mediaItem);
Assert.AreEqual(playlist[0], mediaItem);
Assert.AreEqual(playlist.SelectedItem, mediaItem);
}
public async Task Playlist_ShouldHandleRemoveRangeForUnknownItem()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var playlist = CreatePlaylist(CreateModelPlaylist(), container);
var mediaItems = new List <MediaItem>()
{
CreateMediaItem(new MediaItemModel(), container),
};
Assert.AreEqual(4, playlist.Count);
playlist.RemoveRange(mediaItems);
Assert.AreEqual(4, playlist.Count);
}
public async Task Playlist_ShouldSynchronizeItemsWithModelWhenRemovingSelectedItem()
{
var container = await DependencyInjectionFactory.Get().ConfigureAwait(false);
var model = _context.CreateModelPlaylist();
var playlist = container.CreatePlaylist(model);
var selectedModel = playlist.SelectedItem.Model;
var next = playlist.Next();
Assert.AreEqual(model.MediaItems.Count, playlist.Count);
playlist.Remove(playlist.SelectedItem);
Assert.AreEqual(3, playlist.Count);
Assert.AreEqual(true, selectedModel.IsDeleted);
Assert.AreEqual(next, playlist.SelectedItem);
}
public void When_ConfigureSettings_read_with_multiple_connections_Should_set_them_all_in_ClientConfig()
{
// arrange
var di = DependencyInjectionFactory.ConfigureDependencyInjection();
// act
var clientConfig = di.GetService <IClientConfig>();
// assert
if (!clientConfig.IsAssigned())
{
throw new Exception("mayor fail");
}
clientConfig.Connections.Should().HaveCountGreaterThan(1);
clientConfig.Connections.Where(x => !x.Password.IsAssigned()).Should().HaveCount(0);
}
