/// <summary>
/// Trains a network.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="maxIterationCount">The maximum number of iterations.</param>
/// <param name="maxTolerableNetworkError">The maximum tolerable network error.</param>
public override TrainingLog Train(INetwork network, int maxIterationCount, double maxTolerableNetworkError)
{
// The network genetic algorithm parameters.
NetworkObjectiveFunction networkObjectiveFunction = new NetworkObjectiveFunction(network, trainingSet);
int populationSize = 500;
double crossoverRate = 0.8;
double mutationRate = 0.05;
bool scaling = false;
// Train the network.
int iterationCount;
double networkError;
double[] weights = networkGeneticAlgorithm.Run(networkObjectiveFunction,
maxIterationCount, out iterationCount, maxTolerableNetworkError, out networkError,
populationSize, crossoverRate, mutationRate, scaling
);
network.SetWeights(weights);
// LOGGING
// -------
// Create the training log and log the training data.
TrainingLog trainingLog = new TrainingLog(iterationCount, networkError);
// Log the network statistics.
LogNetworkStatistics(trainingLog, network);
return(trainingLog);
}
public void TestMyLog_UserHasLog_ShouldReturnRedirectToActionLogsControllerDetailsWithCorrectId(string userId)
{
// Arrange
var mockedProvider = new Mock <IAuthenticationProvider>();
mockedProvider.Setup(p => p.CurrentUserId).Returns(userId);
var log = new TrainingLog();
var user = new User {
TrainingLog = log
};
var mockedService = new Mock <IUserService>();
mockedService.Setup(s => s.GetUserById(It.IsAny <string>())).Returns(user);
var mockedFactory = new Mock <IViewModelFactory>();
var controller = new ProfileController(mockedProvider.Object, mockedService.Object, mockedFactory.Object);
// Act, Assert
controller
.WithCallTo(c => c.MyLog())
.ShouldRedirectTo((LogsController c) => c.Details(log.LogId, It.IsAny <int>(), It.IsAny <int>()));
}
public void TestAddEntryToLog_RepositoryReturnsLog_ShouldCallUnitOfWorkCommit(int logId, string username, string userId)
{
// Arrange
var user = new User {
UserName = username, Id = userId
};
var entry = new LogEntry {
EntryDate = new DateTime()
};
var log = new TrainingLog {
User = user
};
var mockedLogRepository = new Mock <IRepository <TrainingLog> >();
mockedLogRepository.Setup(r => r.GetById(It.IsAny <object>()))
.Returns(log);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedLogFactory = new Mock <ITrainingLogFactory>();
var mockedUserService = new Mock <IUserService>();
var mockedDateTimeProvider = new Mock <IDateTimeProvider>();
var service = new LogsService(mockedLogRepository.Object,
mockedUnitOfWork.Object,
mockedLogFactory.Object,
mockedUserService.Object,
mockedDateTimeProvider.Object);
// Act
service.AddEntryToLog(logId, entry, userId);
// Assert
mockedUnitOfWork.Verify(u => u.Commit(), Times.Once);
}
public void TestAddEntryToLog_RepositoryReturnsLog_ShouldAddEntryToLogEntries(int logId, string username, string userId)
{
// Arrange
var user = new User {
UserName = username, Id = userId
};
var entry = new LogEntry();
var log = new TrainingLog {
User = user
};
var mockedLogRepository = new Mock <IRepository <TrainingLog> >();
mockedLogRepository.Setup(r => r.GetById(It.IsAny <object>()))
.Returns(log);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedLogFactory = new Mock <ITrainingLogFactory>();
var mockedUserService = new Mock <IUserService>();
var mockedDateTimeProvider = new Mock <IDateTimeProvider>();
var service = new LogsService(mockedLogRepository.Object,
mockedUnitOfWork.Object,
mockedLogFactory.Object,
mockedUserService.Object,
mockedDateTimeProvider.Object);
// Act
service.AddEntryToLog(logId, entry, userId);
// Assert
CollectionAssert.Contains(log.LogEntries, entry);
}
public void TestAddEntryToLog_RepositoryReturnsLog_ShouldSetLogLastEntryDate(int logId, string username)
{
// Arrange
var user = new User {
UserName = username
};
var entry = new LogEntry {
EntryDate = new DateTime()
};
var log = new TrainingLog {
User = user
};
var mockedLogRepository = new Mock <IRepository <TrainingLog> >();
mockedLogRepository.Setup(r => r.GetById(It.IsAny <object>()))
.Returns(log);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedLogFactory = new Mock <ITrainingLogFactory>();
var mockedUserService = new Mock <IUserService>();
var mockedDateTimeProvider = new Mock <IDateTimeProvider>();
var service = new LogsService(mockedLogRepository.Object,
mockedUnitOfWork.Object,
mockedLogFactory.Object,
mockedUserService.Object,
mockedDateTimeProvider.Object);
// Act
service.AddEntryToLog(logId, entry, null);
// Assert
Assert.AreEqual(entry.EntryDate, log.LastEntryDate);
}
public void TestVoteLog_LogServiceReturnsLog_ShouldReturnCorrectly(int logId, string userId)
{
// Arrange
var mockedRepository = new Mock <IRepository <Vote> >();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var log = new TrainingLog();
var mockedLogService = new Mock <ILogService>();
mockedLogService.Setup(s => s.GetTrainingLogById(It.IsAny <int>())).Returns(log);
var vote = new Vote();
log.Votes.Add(vote);
var mockedVoteFactory = new Mock <IVoteFactory>();
mockedVoteFactory.Setup(f => f.CreateVote(It.IsAny <int>(), It.IsAny <string>())).Returns(vote);
var service = new VoteService(mockedRepository.Object, mockedUnitOfWork.Object, mockedLogService.Object, mockedVoteFactory.Object);
var expected = log.Votes.Count;
// Act
var result = service.VoteLog(logId, userId);
// Assert
Assert.AreEqual(expected, result);
}
public void TestVoteLog_LogServiceReturnsLog_ShouldCallUnitOfWorkCommitCorrectly(int logId, string userId)
{
// Arrange
var mockedRepository = new Mock <IRepository <Vote> >();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var log = new TrainingLog();
var mockedLogService = new Mock <ILogService>();
mockedLogService.Setup(s => s.GetTrainingLogById(It.IsAny <int>())).Returns(log);
var vote = new Vote();
var mockedVoteFactory = new Mock <IVoteFactory>();
mockedVoteFactory.Setup(f => f.CreateVote(It.IsAny <int>(), It.IsAny <string>())).Returns(vote);
var service = new VoteService(mockedRepository.Object, mockedUnitOfWork.Object, mockedLogService.Object, mockedVoteFactory.Object);
// Act
service.VoteLog(logId, userId);
// Assert
mockedUnitOfWork.Verify(u => u.Commit(), Times.Once);
}
public void PostTraining()
{
Training training = new Training();
training.Application = "SDK";
training.Account = "SDK1";
training.Sport = TrainingType.Aerobics;
training.Name = "Name";
training.Source = "SdkSource";
training.Duration = 3600;
training.Start = DateTime.Parse("2021.01.01 12:00:00");
training.End = DateTime.Parse("2021.01.01 13:00:00");
training.Distance = 1;
training.Calories = 6;
training.AverageSpeed = 11;
training.ExternalIdList = new System.Collections.Generic.Dictionary <string, string>();
//training.Pictures=//
TrainingLog trainingLog = new TrainingLog(ApiAdress, true);
trainingLog.PostTraining(training);
var trainingList = trainingLog.TrainingList("SDK1");
Assert.IsTrue(trainingList.Count > 0);
}
public void TestAddEntryToLog_UserIdsDoNotEqual_ShouldNotCallUnitOfWorkCommit(int logId, string userId, string requestUserId)
{
// Arrange
var entry = new LogEntry();
var user = new User {
Id = userId
};
var log = new TrainingLog {
User = user
};
var mockedLogRepository = new Mock <IRepository <TrainingLog> >();
mockedLogRepository.Setup(r => r.GetById(It.IsAny <object>())).Returns(log);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedLogFactory = new Mock <ITrainingLogFactory>();
var mockedUserService = new Mock <IUserService>();
var mockedDateTimeProvider = new Mock <IDateTimeProvider>();
var service = new LogsService(mockedLogRepository.Object,
mockedUnitOfWork.Object,
mockedLogFactory.Object,
mockedUserService.Object,
mockedDateTimeProvider.Object);
// Act
service.AddEntryToLog(logId, entry, requestUserId);
// Assert
mockedUnitOfWork.Verify(u => u.Commit(), Times.Never);
}
public void TestDetails_ShouldReturnView(int id, string userId)
{
// Arrange
var user = new User {
Id = userId
};
var log = new TrainingLog {
User = user
};
var mockedLogService = new Mock <ILogService>();
mockedLogService.Setup(s => s.GetTrainingLogById(It.IsAny <int>())).Returns(log);
var mockedAuthenticationProvider = new Mock <IAuthenticationProvider>();
var mockedFactory = new Mock <IViewModelFactory>();
var controller = new LogsController(mockedLogService.Object, mockedAuthenticationProvider.Object,
mockedFactory.Object);
// Act
var result = controller.Details(id);
// Assert
Assert.IsInstanceOf <ViewResult>(result);
}
public void TestCreate_ShouldSetDetailsViewIdCorrectly(int logId, string name,
string description, string userId)
{
// Arrange
var log = new TrainingLog {
LogId = logId
};
var mockedLogService = new Mock <ILogService>();
mockedLogService.Setup(s => s.CreateTrainingLog(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(log);
var mockedAuthenticationProvider = new Mock <IAuthenticationProvider>();
mockedAuthenticationProvider.Setup(p => p.CurrentUserId).Returns(userId);
var mockedFactory = new Mock <IViewModelFactory>();
var model = new CreateLogViewModel {
Description = description, Name = name
};
var controller = new LogsController(mockedLogService.Object, mockedAuthenticationProvider.Object,
mockedFactory.Object);
// Act, Assert
controller
.WithCallTo(c => c.Create(model))
.ShouldRedirectTo((LogsController c) => c.Details(logId, It.IsAny <int>(), It.IsAny <int>()));
}
public void TestDetails_ShouldCallAuthenticationProviderCurrentUserId(int id, string userId)
{
// Arrange
var user = new User {
Id = userId
};
var log = new TrainingLog {
User = user
};
var mockedLogService = new Mock <ILogService>();
mockedLogService.Setup(s => s.GetTrainingLogById(It.IsAny <int>())).Returns(log);
var mockedAuthenticationProvider = new Mock <IAuthenticationProvider>();
var mockedFactory = new Mock <IViewModelFactory>();
var controller = new LogsController(mockedLogService.Object, mockedAuthenticationProvider.Object,
mockedFactory.Object);
// Act
controller.Details(id);
// Assert
mockedAuthenticationProvider.Verify(p => p.CurrentUserId, Times.Once);
}
/// <summary>
/// Trains a network.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="maxIterationCount">The maximum number of iterations.</param>
/// <param name="maxTolerableNetworkError">The maximum tolerable network error.</param>
public override TrainingLog Train(INetwork network, int maxIterationCount, double maxTolerableNetworkError)
{
// The network ant colony optimiaztion parameters.
NetworkObjectiveFunction networkObjectiveFunction = new NetworkObjectiveFunction(network, trainingSet);
int antCount = 100;
int normalPDFCount = 10;
double requiredAccuracy = 0.001;
// Train the network.
int iterationCount;
double networkError;
double[] weights = networkAntColonyOptimization.Run(networkObjectiveFunction,
maxIterationCount, out iterationCount, maxTolerableNetworkError, out networkError,
antCount, normalPDFCount, requiredAccuracy
);
network.SetWeights(weights);
// LOGGING
// -------
// Create the training log and log the training data.
TrainingLog trainingLog = new TrainingLog(iterationCount, networkError);
// Log the network statistics.
LogNetworkStatistics(trainingLog, network);
return(trainingLog);
}
public void TestNewLog_CurrentUserHasLog_ShouldCallFactoryCreate(int logId)
{
// Arrange
var mockedProvider = new Mock <IAuthenticationProvider>();
var log = new TrainingLog {
LogId = logId
};
var user = new User {
TrainingLog = log, LogId = logId
};
var mockedService = new Mock <IUserService>();
mockedService.Setup(s => s.GetUserById(It.IsAny <string>())).Returns(user);
var mockedFactory = new Mock <IViewModelFactory>();
var controller = new ProfileController(mockedProvider.Object, mockedService.Object, mockedFactory.Object);
// Act
var result = controller.NewLog();
// Assert
mockedFactory.Verify(f => f.CreateNewLogViewModel(logId), Times.Once);
}
public void TestDetails_ShouldCallFactoryCreateLogEntryViewModel_AsManyTimesAsLogEntriesCount(int id, string userId)
{
// Arrange
var user = new User {
Id = userId
};
var log = new TrainingLog {
User = user
};
var mockedLogService = new Mock <ILogService>();
mockedLogService.Setup(s => s.GetTrainingLogById(It.IsAny <int>())).Returns(log);
var mockedAuthenticationProvider = new Mock <IAuthenticationProvider>();
var mockedFactory = new Mock <IViewModelFactory>();
var controller = new LogsController(mockedLogService.Object, mockedAuthenticationProvider.Object,
mockedFactory.Object);
// Act
var result = controller.Details(id);
// Assert
mockedFactory.Verify(f => f.CreateLogEntryViewModel(It.IsAny <LogEntry>(), userId), Times.Exactly(log.Entries.Count));
}
public void TestCreate_ShouldCallLogServiceCreateTrainingLog(int logId, string name,
string description, string userId)
{
// Arrange
var log = new TrainingLog {
LogId = logId
};
var mockedLogService = new Mock <ILogService>();
mockedLogService.Setup(s => s.CreateTrainingLog(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(log);
var mockedAuthenticationProvider = new Mock <IAuthenticationProvider>();
mockedAuthenticationProvider.Setup(p => p.CurrentUserId).Returns(userId);
var mockedFactory = new Mock <IViewModelFactory>();
var model = new CreateLogViewModel {
Description = description, Name = name
};
var controller = new LogsController(mockedLogService.Object, mockedAuthenticationProvider.Object,
mockedFactory.Object);
// Act
controller.Create(model);
// Assert
mockedLogService.Verify(p => p.CreateTrainingLog(name, description, userId), Times.Once);
}
/// <summary>
/// Trains a network.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="maxIterationCount">The maximum number of iterations.</param>
/// <param name="maxTolerableNetworkError">The maximum tolerable network error.</param>
public override TrainingLog Train(INetwork network, int maxIterationCount, double maxTolerableNetworkError)
{
// The network simulated annealing parameters.
NetworkObjectiveFunction networkObjectiveFunction = new NetworkObjectiveFunction(network, trainingSet);
double initialTemperature = 1000.0;
double finalTemperature = 0.001;
// Train the network.
int iterationCount;
double networkError;
double[] weights = networkSimulatedAnnealing.Run(networkObjectiveFunction,
maxIterationCount, out iterationCount, maxTolerableNetworkError, out networkError,
initialTemperature, finalTemperature
);
network.SetWeights(weights);
// LOGGING
// -------
// Create the training log and log the training data.
TrainingLog trainingLog = new TrainingLog(iterationCount, networkError);
// Log the network statistics.
LogNetworkStatistics(trainingLog, network);
return(trainingLog);
}
public void TestDeleteLog_RepositoryReturnsLog_ShouldSetUserLogToNull(int logId)
{
// Arrange
var user = new User();
var log = new TrainingLog {
User = user
};
user.Log = log;
var mockedLogRepository = new Mock <IRepository <TrainingLog> >();
mockedLogRepository.Setup(r => r.GetById(It.IsAny <object>())).Returns(log);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedLogFactory = new Mock <ITrainingLogFactory>();
var mockedUserService = new Mock <IUserService>();
var mockedDateTimeProvider = new Mock <IDateTimeProvider>();
var service = new LogsService(mockedLogRepository.Object,
mockedUnitOfWork.Object,
mockedLogFactory.Object,
mockedUserService.Object,
mockedDateTimeProvider.Object);
// Act
service.DeleteLog(logId);
// Assert
Assert.IsNull(user.Log);
}
public void TestNewLog_CurrentUserHasLog_ShouldSetCorrectViewModel()
{
// Arrange
var mockedProvider = new Mock <IAuthenticationProvider>();
var log = new TrainingLog();
var user = new User {
TrainingLog = log, LogId = log.LogId
};
var mockedService = new Mock <IUserService>();
mockedService.Setup(s => s.GetUserById(It.IsAny <string>())).Returns(user);
var model = new NewLogViewModel();
var mockedFactory = new Mock <IViewModelFactory>();
mockedFactory.Setup(f => f.CreateNewLogViewModel(It.IsAny <int>())).Returns(model);
var controller = new ProfileController(mockedProvider.Object, mockedService.Object, mockedFactory.Object);
// Act, Assert
controller
.WithCallTo(c => c.NewLog())
.ShouldRenderDefaultView()
.WithModel <NewLogViewModel>(m => Assert.AreSame(model, m));
}
public void TestEditLog_RepositoryReturnsLog_ShouldSetLogName(int logId, string newDescription, string newName)
{
// Arrange
var log = new TrainingLog();
var mockedLogRepository = new Mock <IRepository <TrainingLog> >();
mockedLogRepository.Setup(r => r.GetById(It.IsAny <object>())).Returns(log);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedLogFactory = new Mock <ITrainingLogFactory>();
var mockedUserService = new Mock <IUserService>();
var mockedDateTimeProvider = new Mock <IDateTimeProvider>();
var service = new LogsService(mockedLogRepository.Object,
mockedUnitOfWork.Object,
mockedLogFactory.Object,
mockedUserService.Object,
mockedDateTimeProvider.Object);
// Act
service.EditLog(logId, newDescription, newName);
// Assert
Assert.AreEqual(newName, log.Name);
}
/// <summary>
/// Trains a network.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="maxRunCount">The maximum number of runs.</param>
/// <param name="maxIterationCout">The maximum number of iterations.</param>
/// <param name="maxTolerableNetworkError">The maximum tolerable network error.</param>
public TrainingLog Train(INetwork network, int maxRunCount, int maxIterationCout, double maxTolerableNetworkError)
{
// The backpropagation parameters.
int networkErrorUpdateInterval = 100;
bool accumulatedLearning = true;
// Setup:
// Decorate the network as backpropagation network.
BackpropagationNetwork backpropagationNetwork = new BackpropagationNetwork(network);
int bestIterationCount = 0;
double bestNetworkError = backpropagationNetwork.CalculateError(trainingSet);
double[] bestWeights = backpropagationNetwork.GetWeights();
int runCount = 0;
while ((runCount < maxRunCount) && (bestNetworkError > maxTolerableNetworkError))
{
int iterationCount;
double networkError;
Train(backpropagationNetwork, maxIterationCout, out iterationCount, maxTolerableNetworkError, out networkError, networkErrorUpdateInterval, accumulatedLearning);
if (networkError < bestNetworkError)
{
bestIterationCount = iterationCount;
bestNetworkError = networkError;
bestWeights = backpropagationNetwork.GetWeights();
}
runCount++;
// DEBUG
Console.Write(".");
}
// DEBUG
Console.WriteLine();
backpropagationNetwork.SetWeights(bestWeights);
// Teardown:
// Undecorate the backpropagation network as network.
network = backpropagationNetwork.GetDecoratedNetwork();
// LOGGING
// -------
// Create the training log and log the training data.
TrainingLog trainingLog = new TrainingLog(runCount, bestIterationCount, bestNetworkError);
// Log the network statistics.
LogNetworkStatistics(trainingLog, network);
return(trainingLog);
}
public void TestUserId_ShouldInitializeCorrectly(string userId)
{
// Arrange
var log = new TrainingLog();
// Act
log.UserId = userId;
// Assert
Assert.AreEqual(userId, log.UserId);
}
public void TestConstructor_ShouldSetCanVoteCorrectly(bool canVote)
{
// Arrange
var trainingLog = new TrainingLog();
// Act
var model = new LogDetailsViewModel(trainingLog, true, false, canVote, null);
// Assert
Assert.AreEqual(canVote, model.CanVote);
}
public void TestLastEntryId_ShouldInitializeCorrectly(int lastEntryId)
{
// Arrange
var log = new TrainingLog();
// Act
log.LastEntryId = lastEntryId;
// Assert
Assert.AreEqual(lastEntryId, log.LastEntryId);
}
public void TestConstructor_LogUserIsNull_ShouldSetProfileImageUrlNull()
{
// Arrange
var trainingLog = new TrainingLog();
// Act
var model = new LogDetailsViewModel(trainingLog, true, true, true, null);
// Assert
Assert.IsNull(model.ProfileImageUrl);
}
public ShortLogViewModel(TrainingLog log)
{
this.DateCreated = log.DateCreated;
this.Entries = log.LogEntries.Count;
this.LastActivity = log.LastEntryDate;
this.Name = log.Name;
this.LastActivityUser = log.LastActivityUser;
this.LogId = log.LogId;
this.Votes = log.Votes.Count;
this.Username = log.Owner;
}
public void TestLog_ShouldInitializeCorrectly()
{
// Arrange
var log = new TrainingLog();
var logEntry = new LogEntry();
// Act
logEntry.TrainingLog = log;
// Assert
Assert.AreSame(log, logEntry.TrainingLog);
}
public void TestConstructor_ShouldSetNameCorrectly(string name, string description)
{
// Arrange
var dateCreated = new DateTime();
var user = new User();
// Act
var log = new TrainingLog(name, description, dateCreated, user);
// Assert
Assert.AreEqual(name, log.Name);
}
public void TestConstructor_ShouldSetLastEntryDateToDateCreated(string name, string description)
{
// Arrange
var dateCreated = new DateTime();
var user = new User();
// Act
var log = new TrainingLog(name, description, dateCreated, user);
// Assert
Assert.AreEqual(dateCreated, log.LastEntryDate);
}
public void TestLog_ShouldSetCorrectly()
{
// Arrange
var log = new TrainingLog();
var subscription = new Subscription();
// Act
subscription.TrainingLog = log;
// Assert
Assert.AreSame(log, subscription.TrainingLog);
}
