public void WhenCreated_Status_IsDifferentOpen()
{
//act
var test = new ManagerTask("my name", "Closed");
//assert
Assert.Equal("Open", test.Status);
}
public void WhenCreated_Date_Should_be_Now()
{
//act
var test = new ManagerTask("my name", "Closed");
//assert
UnitTestUtility.DateTimeAssertAreEqual(DateTime.UtcNow, test.TimeStamp, TimeSpan.FromMinutes(0.5));
}
public void AdaptManagerTaskModelToManagerTask()
{
var fromValue = UnitTestUtility.GetTaskOnModelToEntity();
var toValue = new ManagerTask(fromValue.Name, fromValue.Status);
SystemUnderTest.Adapt(fromValue, toValue);
UnitTestUtility.AssertAreEqual(fromValue, toValue);
}
/// <summary>
/// From Model to Data Entity
/// </summary>
/// <param name="fromValue"></param>
/// <param name="toValue"></param>
public void Adapt(ManagerTaskModel fromValue, ManagerTask toValue)
{
Guard.Against.Null(fromValue, nameof(fromValue));
Guard.Against.Null(toValue, nameof(toValue));
toValue.Id = fromValue.Id;
toValue.CreationCount = fromValue.CreationCount;
toValue.ModificationCount = fromValue.ModificationCount;
}
/// <summary>
/// From Entity to Model
/// </summary>
/// <param name="expected"></param>
/// <param name="actual"></param>
public static void AssertAreEqual(ManagerTask expected, ManagerTaskModel actual)
{
Assert.Equal(expected.Id, actual.Id);
Assert.Equal <string>(expected.Name, actual.Name);
Assert.Equal <string>(expected.Status, actual.Status);
Assert.Equal <int>(expected.CreationCount, actual.CreationCount);
Assert.Equal <int>(expected.ModificationCount, actual.ModificationCount);
DateTimeAssertAreEqual(expected.TimeStamp, actual.TimeStamp, TimeSpan.FromMinutes(0.1));
}
public static ManagerTask GetManagerTaskAsEntityDb_TaskJob()
{
var info = new ManagerTask("Create a new task this for work", TaskManagerConstant.Open)
{
ModificationCount = 1
};
return(info);
}
void SetManagerTask(ManagerTask task)
{
Teams.SetManagerTask(Flagship, SelectedTeam, ChosenIndex, task);
OnDeselectAll();
//TeamView.SetEntity(Flagship.team.Teams[SelectedTeam], SelectedTeam);
ViewRender();
}
public void Given_AnUnManagerTaskModelWhenAdaptIsCalledTwiceThen_NoDuplicatesAreCreated()
{
var fromValue = UnitTestUtility.GetTaskOnModelToEntity();
var toValue = new ManagerTask(fromValue.Name, fromValue.Status);
SystemUnderTest.Adapt(fromValue, toValue);
SystemUnderTest.Adapt(fromValue, toValue);
UnitTestUtility.AssertAreEqual(fromValue, toValue);
}
public void DeletePresidentByIdRemovesPresidentFromRepository()
{
PopulateWithTaskManagerData();
ManagerTask expected = GetManagerTaskDbByNameFromTestRepository("Create a new task this for work");
SystemUnderTest.DeleteTaskById(expected.Id);
Assert.Null(MtRepositoryInstance.GetById(expected.Id));
}
/// <summary>
/// From database Entity to model
/// </summary>
/// <param name="fromValue"></param>
/// <param name="toValue"></param>
public void Adapt(ManagerTask fromValue, ManagerTaskModel toValue)
{
Guard.Against.Null(fromValue, nameof(fromValue));
Guard.Against.Null(toValue, nameof(toValue));
toValue.Id = fromValue.Id;
toValue.Name = fromValue.Name;
toValue.Status = fromValue.Status;
toValue.TimeStamp = fromValue.TimeStamp;
toValue.CreationCount = fromValue.CreationCount;
toValue.ModificationCount = fromValue.ModificationCount;
}
public void GetPresidentById()
{
PopulateWithTaskManagerData();
ManagerTask expected = GetManagerTaskDbByNameFromTestRepository("Create a new task this for work");
ManagerTaskModel actual = SystemUnderTest.GetTaskById(expected.Id);
Assert.NotNull(actual);
Assert.Equal(expected.Id, actual.Id);
Assert.Equal(expected.Name, actual.Name);
}
private void PopulateWithTaskManagerData()
{
MtRepositoryInstance.Save(UnitTestUtility.GetManagerTaskAsEntityDb_TaskJob());
var taskdb = new ManagerTask("Create an application in C#", TaskManagerConstant.Open);
MtRepositoryInstance.Save(taskdb);
var taskdb2 = new ManagerTask("Create an application in Java", TaskManagerConstant.Open);
MtRepositoryInstance.Save(taskdb2);
var taskdb3 = new ManagerTask("Create an application in html", TaskManagerConstant.Complete);
MtRepositoryInstance.Save(taskdb3);
}
public void SetEntity(int index)
{
SlotId = index;
ManagerTask task = Flagship.team.Teams[SelectedTeam].ManagerTasks[index]; // RandomEnum<ManagerTask>.GenerateValue();
switch (task)
{
case ManagerTask.None:
TaskImage.texture = None;
Blinker.enabled = true;
break;
case ManagerTask.Documentation:
TaskImage.texture = Bureaucracy;
Blinker.enabled = false;
break;
case ManagerTask.Investments:
TaskImage.texture = SearchInvestments;
Blinker.enabled = false;
break;
case ManagerTask.Recruiting:
TaskImage.texture = Recruiting;
Blinker.enabled = false;
break;
case ManagerTask.Organisation:
TaskImage.texture = Organisation;
Blinker.enabled = false;
break;
case ManagerTask.Polishing:
TaskImage.texture = ProductPolishing;
Blinker.enabled = false;
break;
case ManagerTask.ViralSpread:
TaskImage.texture = ViralGrowth;
Blinker.enabled = false;
break;
case ManagerTask.ImproveAtmosphere:
TaskImage.texture = ProxyTasks;
Blinker.enabled = false;
break;
}
}
public static void SetManagerTask(GameEntity company, int teamId, int taskId, ManagerTask managerTask)
{
var tasks = company.team.Teams[teamId].ManagerTasks;
if (tasks.Count < taskId)
{
tasks.Add(managerTask);
}
else
{
tasks[taskId] = managerTask;
}
//company.team.Teams[teamId].ManagerTasks[taskId] = managerTask;
}
public void TestMethod1()
{
// Arrange
var managerMock = new Mock <ITaskKeeper>();
managerMock.Setup(p => p.GetNext(It.IsAny <List <ProcessedEntityType> >())).Returns(() => new ManagerTask());
// Act
ManagerTask result = managerMock.Object.GetNext(new List <ProcessedEntityType>
{
ProcessedEntityType.Video,
ProcessedEntityType.Screenshot
});
// Assert
Assert.IsNotNull(result);
}
/// <summary>
/// Save with validation of task duplication
/// </summary>
/// <param name="saveThis"></param>
public void Save(ManagerTaskModel saveThis)
{
Guard.Against.Null(saveThis, nameof(saveThis));
if (_validatorInstance.IsValid(saveThis) == false)
{
throw new InvalidOperationException("Task is invalid.");
}
ManagerTask toValue;
if (saveThis.Id != 0)
{
toValue = _repositoryInstance.GetById(saveThis.Id);
if (toValue == null)
{
throw new InvalidOperationException(TaskManagerConstant.MsgColdNotLocateATaskWithId + $" '{saveThis.Id}'.");
}
}
var match = VerifyDuplication(saveThis);
if (match)
{
throw new InvalidOperationException(TaskManagerConstant.MsgCanNotSaveDuplicateTask);
}
toValue = new ManagerTask(saveThis.Name, saveThis.Status);
_adapter.Adapt(saveThis, toValue);
_repositoryInstance.Save(toValue);
saveThis.Id = toValue.Id;
}
// --------------------------------
public static int GetManagerFocusBonus(GameContext gameContext, GameEntity company, TeamInfo teamInfo, ManagerTask managerTask)
{
bool hasMainManager = Teams.HasMainManagerInTeam(teamInfo);
if (hasMainManager)
{
return(teamInfo.ManagerTasks.Count(t => t == managerTask));
}
return(0);
}
public void Dispose()
{
_systemUnderTest = null;
}
