public void SettingSelectedProjectSortOptionToSameValueDoesNotRaisePropertyChanged()
{
// Arrange
var alphabeticalSort = new AlphabeticalSort();
var propertyChangedRaised = false;
var builder = new UserPreferencesBuilder();
var preferences = builder.CreateUserPreferences();
var handler = new PropertyChangedEventHandler((s, e) =>
{
propertyChangedRaised = true;
});
preferences.SelectedProjectSortOption = alphabeticalSort;
preferences.PropertyChanged += handler;
// Act
preferences.SelectedProjectSortOption = alphabeticalSort;
preferences.PropertyChanged -= handler;
// Assert
Assert.IsFalse(propertyChangedRaised);
}
public void BeginningOfAlphabetAppearsAtStartOfSortedList()
{
// Arrange
const string displayNameA = "A";
var metadataList = new List <DocumentMetadata>
{
CreateDocumentMetadata("B"),
CreateDocumentMetadata("C"),
CreateDocumentMetadata(displayNameA)
};
var sortOption = new AlphabeticalSort();
var sortDescription = sortOption.GetSortDescription();
var view = new ListCollectionView(metadataList);
// Act
view.SortDescriptions.Add(sortDescription);
// Assert
view.MoveCurrentToFirst();
var firstItem = (DocumentMetadata)view.CurrentItem;
Assert.That(firstItem.DisplayName, Is.EqualTo(displayNameA));
}
public void SortDescriptionIsReturnedForApplicableSelectedProjectSortOption()
{
// Arrange
var alphabeticalSort = new AlphabeticalSort();
var preferences = Mock.Of <IUserPreferences>(p =>
p.DocumentSortOption == Mock.Of <ISortOption>(s =>
s.HasSortDescription == false) &&
p.ProjectSortOption == alphabeticalSort);
var service = new SortOptionsService();
// Act
var appliedSortOptions = service.EvaluateAppliedSortDescriptions(
preferences);
// Assert
// Returned collection should only contain sort option for
// ProjectSortOption: DocumentSortOption.HasSortDescription is set
// to return false
Assert.That(appliedSortOptions.Length, Is.EqualTo(1));
Assert.That(
appliedSortOptions[0].Direction,
Is.EqualTo(alphabeticalSort.SortDirection));
Assert.That(
appliedSortOptions[0].PropertyName,
Is.EqualTo(alphabeticalSort.PropertyName));
}
public void HasSortDescriptionIsTrue()
{
// Arrange
var sortOption = new AlphabeticalSort();
// Assert
Assert.IsTrue(sortOption.HasSortDescription);
}
public void BeforeEachTest()
{
_alphabeticalAlgorithm = Substitute.For <AlphabeticalSort>();
_randomAlgorithm = Substitute.For <RandomSort>();
_sorter = new SessionSorter(_alphabeticalAlgorithm, _randomAlgorithm);
_sessions = new List <SessionDisplayModel>();
_sessions.Add(new SessionDisplayModel());
_sessions.Add(new SessionDisplayModel());
_sessions.Add(new SessionDisplayModel());
}
public void ApplicableTypeIsCorrect()
{
// Arrange
var sortOption = new AlphabeticalSort();
// Act
var isDocumentType =
sortOption.ApplicableType == ProjectItemType.Document;
// Assert
Assert.IsTrue(isDocumentType);
}
public void ProjectSortIsReturnedBeforeDocumentSort()
{
// Arrange
var alphabeticalSort = new AlphabeticalSort();
var projectReverseAlphabeticalSort = new ProjectReverseAlphabeticalSort();
var builder = new UserPreferencesBuilder();
var preferences = builder.CreateUserPreferences();
preferences.SelectedDocumentSortOption = alphabeticalSort;
preferences.SelectedProjectSortOption = projectReverseAlphabeticalSort;
var service = new SortOptionsService();
// Act
var appliedSortOptions = service.EvaluateAppliedSortDescriptions(
preferences);
// Assert
Assert.That(appliedSortOptions.Length, Is.EqualTo(2));
Assert.That(
appliedSortOptions[0].Direction,
Is.EqualTo(projectReverseAlphabeticalSort.SortDirection));
Assert.That(
appliedSortOptions[0].PropertyName,
Is.EqualTo(projectReverseAlphabeticalSort.PropertyName));
Assert.That(
appliedSortOptions[1].Direction,
Is.EqualTo(alphabeticalSort.SortDirection));
Assert.That(
appliedSortOptions[1].PropertyName,
Is.EqualTo(alphabeticalSort.PropertyName));
Assert.That(
appliedSortOptions[0].Direction,
Is.Not.EqualTo(appliedSortOptions[1].Direction));
Assert.That(
appliedSortOptions[0].PropertyName,
Is.Not.EqualTo(appliedSortOptions[1].PropertyName));
}
public void AssignedDisplayOrderMatchesSpecifiedOrder()
{
// Arrange
const int disableSortingIndex = 0;
const int chronologicalSortIndex = 1;
const int alphabeticalSortIndex = 2;
var displayOrder = new Type[3];
displayOrder[disableSortingIndex] = typeof(DisableSorting);
displayOrder[chronologicalSortIndex] = typeof(ChronologicalSort);
displayOrder[alphabeticalSortIndex] = typeof(AlphabeticalSort);
var alphabeticalSort = new AlphabeticalSort();
var chronologicalSort = new ChronologicalSort();
var disableSorting = new DisableSorting();
var sortOptions = new ISortOption[]
{
// Order should be different from indexes specified above
alphabeticalSort,
chronologicalSort,
disableSorting
};
var service = new SortOptionsService();
// Act
service.AssignDisplayOrder(displayOrder, sortOptions);
// Assert
Assert.That(
disableSorting.DisplayIndex,
Is.EqualTo(disableSortingIndex));
Assert.That(
chronologicalSort.DisplayIndex,
Is.EqualTo(chronologicalSortIndex));
Assert.That(
alphabeticalSort.DisplayIndex,
Is.EqualTo(alphabeticalSortIndex));
}
public void ProjectSortIsReturnedBeforeDocumentSort()
{
// Arrange
var alphabeticalSort = new AlphabeticalSort();
var projectReverseAlphabeticalSort = new ProjectReverseAlphabeticalSort();
var preferences = Mock.Of <IUserPreferences>(p =>
p.DocumentSortOption == alphabeticalSort &&
p.ProjectSortOption == projectReverseAlphabeticalSort);
var service = new SortOptionsService();
// Act
var appliedSortOptions = service.EvaluateAppliedSortDescriptions(
preferences);
// Assert
Assert.That(appliedSortOptions.Length, Is.EqualTo(2));
Assert.That(
appliedSortOptions[0].Direction,
Is.EqualTo(projectReverseAlphabeticalSort.SortDirection));
Assert.That(
appliedSortOptions[0].PropertyName,
Is.EqualTo(projectReverseAlphabeticalSort.PropertyName));
Assert.That(
appliedSortOptions[1].Direction,
Is.EqualTo(alphabeticalSort.SortDirection));
Assert.That(
appliedSortOptions[1].PropertyName,
Is.EqualTo(alphabeticalSort.PropertyName));
Assert.That(
appliedSortOptions[0].Direction,
Is.Not.EqualTo(appliedSortOptions[1].Direction));
Assert.That(
appliedSortOptions[0].PropertyName,
Is.Not.EqualTo(appliedSortOptions[1].PropertyName));
}
public void DocumentSortOptionsAppearInSpecifiedOrder()
{
// Arrange
const int chronologicalSortIndex = 0;
const int alphabeticalSortIndex = 1;
var alphabeticalSort = new AlphabeticalSort();
var chronologicalSort = new ChronologicalSort();
var options = new ISortOption[]
{
// Order should be different from indexes specified above
alphabeticalSort,
chronologicalSort
};
var displayOrder = new Type[2];
displayOrder[chronologicalSortIndex] = typeof(ChronologicalSort);
displayOrder[alphabeticalSortIndex] = typeof(AlphabeticalSort);
// Act
var builder = new OptionsListsBuilder
{
SortOptions = options,
SortOptionsDisplayOrder = displayOrder,
SortOptionsService = new SortOptionsService()
};
var lists = builder.CreateOptionsLists();
// Assert
Assert.That(lists.DocumentSortOptions.Count, Is.EqualTo(2));
Assert.That(
lists.DocumentSortOptions[chronologicalSortIndex],
Is.EqualTo(chronologicalSort));
Assert.That(
lists.DocumentSortOptions[alphabeticalSortIndex],
Is.EqualTo(alphabeticalSort));
}
public void SettingSelectedProjectSortOptionStoresNewValueDisplayNameInRepository()
{
// Arrange
var option = new AlphabeticalSort();
var builder = new UserPreferencesBuilder();
var preferences = builder.CreateUserPreferences();
// Act
preferences.SelectedProjectSortOption = option;
// Verify
var typeString = option.ToString();
builder.StoredSettingsRepositoryMock
.Verify(r => r.SetSelectedProjectSortType(typeString));
}
public void SortDescriptionIsReturnedForApplicableSelectedProjectSortOption()
{
// Arrange
var alphabeticalSort = new AlphabeticalSort();
var builder = new UserPreferencesBuilder();
var preferences = builder.CreateUserPreferences();
preferences.SelectedDocumentSortOption = Mock.Of <ISortOption>(s =>
s.HasSortDescription == false);
preferences.SelectedProjectSortOption = alphabeticalSort;
var service = new SortOptionsService();
// Act
var appliedSortOptions = service.EvaluateAppliedSortDescriptions(
preferences);
// Assert
// Returned collection should only contain sort option for
// SelectedProjectSortOption: the ISortOption of
// SelectedDocumentSortOption has its HasSortDescription property
// set to return false
Assert.That(appliedSortOptions.Length, Is.EqualTo(1));
Assert.That(
appliedSortOptions[0].Direction,
Is.EqualTo(alphabeticalSort.SortDirection));
Assert.That(
appliedSortOptions[0].PropertyName,
Is.EqualTo(alphabeticalSort.PropertyName));
}
