public override string ToString()
        {
            string effortString   = "{0} ";
            string burnPartString = string.Empty;
            bool   needSpace      = false;

            if (Effort > 0)
            {
                effortString += "({" + "1" + "})";
                if (DevEffort > 0)
                {
                    burnPartString = "Dev:" + DevEffort.ToString();
                    needSpace      = true;
                }
                if (QAEffort > 0)
                {
                    if (needSpace)
                    {
                        burnPartString += " ";
                    }
                    burnPartString += "QA:" + QAEffort.ToString();
                    needSpace       = true;
                }
                if (TWEffort > 0)
                {
                    if (needSpace)
                    {
                        burnPartString += " ";
                    }
                    burnPartString += "TW:" + TWEffort.ToString();
                }
            }

            return(string.Format(effortString, Effort.ToString(), burnPartString));
        }
        /// <summary>
        /// Finds Effort By Id
        /// </summary>
        /// <param name="id">Injected <see cref="int"/></param>
        /// <returns>Instance of <see cref="Task{Effort}"/></returns>
        public async Task <Effort> FindEffortById(int @id)
        {
            Effort @effort = await Context.Effort
                             .TagWith("FindEffortById")
                             .FirstOrDefaultAsync(x => x.Id == @id);

            if (@effort == null)
            {
                // Log
                string @logData = @effort.GetType().Name
                                  + " with Id "
                                  + @id
                                  + " was not found at "
                                  + DateTime.Now.ToShortTimeString();

                Logger.WriteGetItemNotFoundLog(@logData);

                throw new Exception(@effort.GetType().Name
                                    + " with Id "
                                    + @id
                                    + " does not exist");
            }

            return(@effort);
        }
        /// <summary>
        /// De Activates Stop
        /// </summary>
        /// <param name="viewmodel">Injected <see cref="AddEffort"/></param>
        /// <returns>Instance of <see cref="Task"/></returns>
        public async Task DeActivateStop(AddEffort @viewmodel)
        {
            Effort @effort = await this.FindFormerDayActiveEffortByApplicationUserId(@viewmodel.ApplicationUserId);

            if (@effort != null)
            {
                if (@effort.Kind.Id.Equals((int)EffortKinds.Stop))
                {
                    @effort.Active = false;
                    @effort.Finish = DateTime.Now;

                    Context.Effort.Update(@effort);

                    // Log
                    string @logData = @effort.GetType().Name
                                      + " with Id "
                                      + @effort.Id
                                      + " was updated at "
                                      + DateTime.Now.ToShortTimeString();

                    Logger.WriteUpdateItemLog(@logData);
                }
                else
                {
                    throw new Exception(@effort.GetType().Name
                                        + " with Id "
                                        + @effort.Id
                                        + " can not be stopped");
                }
            }
        }
Beispiel #4
0
        public HttpResponseMessage insertNewTask([FromBody] Effort effort)
        {
            try
            {
                using (var unitOfWork = new UnitOfWork(new FoolStaffContext()))
                {
                    Effort oEffort = new Effort();
                    oEffort.Titolo        = effort.Titolo;
                    oEffort.Descrizione   = effort.Descrizione;
                    oEffort.Priorita      = effort.Priorita;
                    oEffort.DataCreazione = UtilDate.CurrentTimeMillis();
                    oEffort.Stato         = "OPEN";

                    unitOfWork.Efforts.Add(oEffort);
                    unitOfWork.Complete();

                    var entity = unitOfWork.Efforts.Find(t => t.Stato == "OPEN").OrderByDescending(t => t.Priorita).ToList();
                    log.Debug("insertNewTask - task inserito correttamente");
                    return(Request.CreateResponse(HttpStatusCode.OK, entity));
                }
            }
            catch (Exception ex)
            {
                log.Error("insertNewTask - errore nell'inserimento del task ", ex);
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
            }
        }
        public static bool EffortEdit(Effort effort)
        {
            bool ret     = true;
            User curUser = Viola.Models.User.GetCurrentUser();

            // company kontrolü
            if (effort.CompanyId != curUser.CompanyId)
            {
                ret = false;
            }

            // kullanıcı eforunu sadece yetkisi olduğu tasklara girebilir
            if (!Task.GetTasksByRole().Where(x => x.Id == effort.TaskId).Any())
            {
                ret = false;
            }

            // kullanıcılar sadece yetkileri olduğu kişilerin eforlarını düzenleyebilir
            // admin: herkesi
            // user: sadece kendisini
            if (!Viola.Models.User.GetUsersForEffort().Where(x => x.Id == effort.UserId).Any())
            {
                ret = false;
            }

            return(ret);
        }
Beispiel #6
0
        public void TestMediumEffort()
        {
            var circuit = sampleCircuit(0, 8, 0);
            var level   = new Level(2, breakTime: 20, switchTime: 0, exerciseTime: 10);

            Assert.AreEqual(level.Effort(circuit), Effort.FromRatio((double)160 / 200));
        }
Beispiel #7
0
        public HttpResponseMessage giveUpTask(string userId, [FromBody] int idEffort)
        {
            try
            {
                using (var unitOfWork = new UnitOfWork(new FoolStaffContext()))
                {
                    User   entityUser = unitOfWork.Users.Search(u => u.Id == userId).SingleOrDefault();
                    Effort entityTask = unitOfWork.Efforts.Search(t => t.Id == idEffort).Include(c => c.Users).SingleOrDefault();

                    if (entityTask.Users.Contains(entityUser))
                    {
                        entityTask.Users.Remove(entityUser);
                        unitOfWork.Complete();
                    }

                    var entity = unitOfWork.Efforts.Find(t => t.Stato == "OPEN").OrderByDescending(t => t.Priorita).ToList();
                    log.Debug("giveUpTask - rinuncia al task da parte dell'utente id [" + entityUser.Id + "] avvenuta con successo");
                    return(Request.CreateResponse(HttpStatusCode.OK, entity));
                }
            }
            catch (Exception ex)
            {
                log.Error("giveUpTask - errore nella rinuncia al task ", ex);
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
            }
        }
Beispiel #8
0
 public void UpdateDisplay(Effort effort)
 {
     text.text = "";
     foreach (Effort.EffortType type in System.Enum.GetValues(typeof(Effort.EffortType)))
     {
         text.text += type + ": " + effort.GetEffort(type) + " / " + effort.GetMaxEffort(type) + "\n";
     }
 }
        public void TestGetEffort()
        {
            Effort effort = Instance.Get.EffortByID(AssetID.FromToken("Actual:1448"));

            Assert.IsNotNull(effort);
            Assert.AreEqual(4, effort.Value);
            Assert.AreEqual("Boris Tester", effort.Member.Name);
        }
Beispiel #10
0
        public async Task <IActionResult> UpdateEffort(Guid Id, Effort effort)
        {
            effort.Id = Id;

            return(Ok(await Mediator.Send(new Edit.Command {
                Effort = effort
            })));
        }
Beispiel #11
0
        public void CreateEffort(Effort cmd)
        {
            if (cmd == null)
            {
                throw new ArgumentNullException(nameof(cmd));
            }

            _access.Efforts.Add(cmd);
        }
 private Task(string title, Guid teamId, Priority priority, Effort effort) : base(title, teamId, priority)
 {
     if (effort == null)
     {
         throw new DomainException(nameof(Effort), "Effort cannot be empty");
     }
     State       = WorkItemState.New;
     StateReason = StateReason.New;
     Effort      = effort;
 }
        public Effort Create(Effort effort)
        {
            var req = _contextProvider.Requirements.Find(effort.RequirementId);

            if (req == null)
                throw new NotFoundException("Requirement not found.");

            var user = _contextProvider.Users.Find(effort.UserId);

            if(user == null)
                throw new NotFoundException("User not found.");

            var project = _contextProvider.Projects.Find(req.ProjectId);

            if(project == null)
                throw new NotFoundException("Project not found.");

            if(project.UserId != effort.UserId && project.Users.All(p => p.UserId != effort.UserId))
                throw new UnauthorizedAccessException("User does not have access to project.");

            if(project.StartDate.HasValue && project.StartDate > effort.StartDate)
                throw new ValidationException("Invalid start date.");

            if (project.EndDate.HasValue && project.EndDate < effort.EndDate)
                throw new ValidationException("Invalid end date.");

            if(effort.StartDate > DateTime.Now.Date)
                throw new ValidationException("Invalid start date.");

            if (effort.EndDate.Date > DateTime.Now.Date)
                throw new ValidationException("Invalid end date.");

            if(effort.Hours <= 0)
                throw new ValidationException("Hours must be greater than 0.");

            var startDate = effort.StartDate.DayOfYear;
            var endDate = effort.EndDate.DayOfYear;
            var dateDiff = endDate - startDate;

            if (dateDiff != 0 && dateDiff != 6)
                throw new ValidationException("Invalid date range.");

            if(dateDiff == 0 && effort.Hours > 24)
                throw new ValidationException("Hours exceed date range.");

            if(dateDiff == 6 && effort.Hours > 168)
                throw new ValidationException("Hours exceed date range.");

            if (effort.EffortTypeId < 0 || effort.EffortTypeId > 5)
                throw new ValidationException("Invalid effort type.");

            var newEffort = _contextProvider.Efforts.Add(effort);
            _contextProvider.SaveChanges();
            return newEffort;
        }
Beispiel #14
0
        public IActionResult AddEffort([FromBody] Effort effort)
        {
            if (effort != null && ModelState.IsValid)
            {
                this.employeeService.AddEmployeeEffort(effort);

                return(new ObjectResult(true));
            }

            return(new ObjectResult(false));
        }
Beispiel #15
0
 public override int GetHashCode()
 {
     unchecked
     {
         var hashCode = Lower.GetHashCode();
         hashCode = (hashCode * 397) ^ Upper.GetHashCode();
         hashCode = (hashCode * 397) ^ Effort.GetHashCode();
         hashCode = (hashCode * 397) ^ Velocity.GetHashCode();
         return(hashCode);
     }
 }
Beispiel #16
0
        public void EffortFactory()
        {
            Effort testEffort1 = Effort.GetNewEffort(1, 2, 3, 4);

            Assert.IsNotNull(testEffort1);
            Assert.AreEqual(testEffort1.TimeElapsed.TotalSeconds, 0);
            Assert.AreEqual(testEffort1.UserId, 1);
            Assert.AreEqual(testEffort1.ContractId, 2);
            Assert.AreEqual(testEffort1.PhaseId, 3);
            Assert.AreEqual(testEffort1.TaskId, 4);
        }
        public async Task <Unit> Handle(AddWorkItemToSprintCommand request, CancellationToken cancellationToken)
        {
            var sprint = await _repository.GetAsync(request.SprintId);

            var effort = new Effort(request.OriginalEstimate, request.Remaining, request.Completed);

            sprint.AddWorkItem(new WorkItem(request.BugId, effort));

            await _repository.UnitOfWork.SaveChangesAsync(cancellationToken);

            return(Unit.Value);
        }
Beispiel #18
0
        public void TestLevelOptimization()
        {
            var expectedDuration = Duration.fromMinutes(30);
            var effort = new Effort(95);
            var circuit = sampleCircuit(0, 8, 0);

            var finder = new Scheduler(circuit, expectedDuration, effort);
            var level = finder.Schedule;

            Assert.AreEqual(Effort.FromRatio(0.95), level.Effort(circuit));
            Assert.AreEqual(30, level.TotalDuration(circuit).inMinutes());
        }
Beispiel #19
0
        public void TestLevelOptimization()
        {
            var expectedDuration = Duration.fromMinutes(30);
            var effort           = new Effort(95);
            var circuit          = sampleCircuit(0, 8, 0);

            var finder = new Scheduler(circuit, expectedDuration, effort);
            var level  = finder.Schedule;

            Assert.AreEqual(Effort.FromRatio(0.95), level.Effort(circuit));
            Assert.AreEqual(30, level.TotalDuration(circuit).inMinutes());
        }
Beispiel #20
0
        public ActionResult DeleteConfirmed(int id)
        {
            Effort effort = db.Efforts.Find(id);

            if (!EntityAuthorization.EffortDelete(effort))
            {
                return(HttpNotFound());
            }

            db.Efforts.Remove(effort);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Beispiel #21
0
 private Bug(string title, Guid teamId, Priority priority, StateReason stateReason, Priority severity,
             Effort effort) : base(title, teamId, priority)
 {
     if (effort == null)
     {
         throw new DomainException(nameof(Effort), "Effort cannot be empty");
     }
     ValidateStateAndStateReason(WorkItemState.New, stateReason);
     State       = WorkItemState.New;
     StateReason = stateReason;
     Severity    = severity;
     Effort      = effort;
 }
        /// <summary>
        /// Finds Last Active Effort By Application User Id
        /// </summary>
        /// <param name="id">Injected <see cref="int"/></param>
        /// <returns>Instance of <see cref="Task{ViewEffort}"/></returns>
        public async Task <ViewEffort> FindLastActiveEffortByApplicationUserId(int @id)
        {
            Effort @effort = await Context.Effort
                             .AsNoTracking()
                             .AsQueryable()
                             .TagWith("FindLastActiveEffortByApplicationUserId")
                             .Include(x => x.ApplicationUser)
                             .Include(x => x.Kind)
                             .Where(x => x.ApplicationUser.Id == @id)
                             .Where(x => x.Active)
                             .OrderByDescending(x => x.LastModified)
                             .FirstOrDefaultAsync(x => x.Active);

            return(Mapper.Map <ViewEffort>(@effort));
        }
Beispiel #23
0
        public void EffortTimeElapsed()
        {
            Effort testEffort1 = Effort.GetNewEffort(1, 2, 3, 4);

            Assert.IsNotNull(testEffort1);
            Assert.AreEqual(testEffort1.TimeElapsed.TotalSeconds, 0);

            Assert.IsTrue(testEffort1.StartEffort());

            System.Threading.Thread.Sleep(1000); // wait for 1 second

            Assert.IsTrue(testEffort1.StopEffort());
            Assert.IsTrue(testEffort1.TimeElapsed.TotalSeconds - 1 <= 0.002);

            Console.WriteLine(testEffort1.TimeElapsed.TotalSeconds);
        }
Beispiel #24
0
        static void Main(string[] args)
        {
            Console.WriteLine("Estimating ...");
            var parsedTime      = int.TryParse(args[0], out int result);
            var parsedIncrement = Enum.TryParse(args[1], true, out TimeIncrement timeIncrement);

            if (!parsedTime || !parsedIncrement)
            {
                Console.WriteLine("I was unable to parse your command.");
                Console.WriteLine("Please format your args accordingly estimate {1} {days, weeks, months}");
                return;
            }
            var effort = Effort.Create(timeIncrement, result);

            Console.WriteLine($"Your Tshirt Size Estimate is: {effort.TshirtSize.TshirtSizeEnum.ToString()} (days: {effort.Days}, weeks: {effort.Weeks}, months: {effort.Months}");
        }
        /// <summary>
        /// De Activates Resume
        /// </summary>
        /// <param name="viewmodel">Injected <see cref="AddEffort"/></param>
        /// <returns>Instance of <see cref="Task"/></returns>
        public async Task DeActivateResume(AddEffort @viewmodel)
        {
            Effort @effort = await FindCurrentDayActiveEffortByApplicationUserId(@viewmodel.ApplicationUserId);

            if (@effort != null)
            {
                if (@effort.Kind.Id.Equals((int)EffortKinds.Resume) || @effort.Kind.Id.Equals((int)EffortKinds.Start))
                {
                    effort.ApplicationUser = await FindApplicationUserById(@viewmodel.ApplicationUserId);

                    @effort.Active = false;
                    @effort.Finish = DateTime.Now;

                    Context.Effort.Update(@effort);

                    // Log
                    string @logData = @effort.GetType().Name
                                      + " with Id "
                                      + @effort.Id
                                      + " was updated at "
                                      + DateTime.Now.ToShortTimeString();

                    Logger.WriteUpdateItemLog(@logData);
                }
                else
                {
                    throw new Exception(@effort.GetType().Name
                                        + " with Id "
                                        + @effort.Id
                                        + " can not be stoppped");
                }
            }
            else
            {
                // Log
                string @logData = @effort.GetType().Name
                                  + " for Application User"
                                  + viewmodel.ApplicationUserId
                                  + " was not found at "
                                  + DateTime.Now.ToShortTimeString();

                Logger.WriteGetItemNotFoundLog(@logData);

                throw new Exception(@effort.GetType().Name
                                    + " was not started");
            }
        }
Beispiel #26
0
        /// <summary>
        /// Save time sheet in to db
        /// </summary>
        public ResulDTO SaveTimeSheet(EmployeeTimeSheetDTO timeSheetDto)
        {
            ResulDTO result = new ResulDTO();

            try
            {
                foreach (var day in timeSheetDto.TimeSheets)
                {
                    foreach (var effort in day.EffortLogs)
                    {
                        Effort dbEffort = db.Efforts.FirstOrDefault(f => f.EmployeeId == timeSheetDto.EmployeeId && f.Date == day.Date &&
                                                                    f.TaskId == effort.TaskId);
                        if (dbEffort != null)
                        {
                            dbEffort.EffortInHrs = effort.EffortInHrs;
                            db.Efforts.Update(dbEffort);
                        }
                        else
                        {
                            dbEffort = new Effort
                            {
                                EmployeeId  = timeSheetDto.EmployeeId,
                                Date        = day.Date,
                                TaskId      = effort.TaskId,
                                EffortInHrs = effort.EffortInHrs
                            };

                            db.Efforts.Add(dbEffort);
                        }
                    }
                }

                db.SaveChanges();
                result.Success = true;
            }
            catch (Exception ex)
            {
                System.Diagnostics.Trace.WriteLine(ex.ToString());
                result.ErrorMsg = "Something went wrong !!, Please try again.";
            }

            return(result);
        }
        /// <summary>
        /// Stops
        /// </summary>
        /// <param name="viewmodel">Injected <see cref="AddEffort"/></param>
        /// <returns>Instance of <see cref="Task{ViewEffort}"/></returns>
        public async Task <ViewEffort> Stop(AddEffort @viewmodel)
        {
            await DeActivateResume(@viewmodel);

            Effort @effort = await AddStopEffort(@viewmodel);

            await Context.SaveChangesAsync();

            // Log
            string @logData = @effort.GetType().Name
                              + " with Id "
                              + @effort.Id
                              + " was added at "
                              + DateTime.Now.ToShortTimeString();

            Logger.WriteInsertItemLog(@logData);

            return(Mapper.Map <ViewEffort>(@effort));
        }
        public Task <Guid> Handle(CreateBugCommand request, CancellationToken cancellationToken)
        {
            var effort  = new Effort(request.OriginalEstimate, request.Remaining, request.Completed);
            var builder = new Bug.BugBuilder(request.Title, request.TeamId, effort, (Priority)request.PriorityId,
                                             (StateReason)request.StateReasonId, (Priority)request.SeverityId);

            builder.SetWorkItemOptionalFields(request.Description, request.AssignedTo, request.SprintId,
                                              String.IsNullOrWhiteSpace(request.RepoLink) ? null : new Link(request.RepoLink));

            builder.SetBugOptionalFields(request.IntegratedInBuild, request.StoryPoints, request.SystemInfo,
                                         request.FoundInBuild);

            var now = _dateTime.UtcNow;

            foreach (var dto in request.RelatedWorks)
            {
                builder.AddRelatedWork(dto.ToRelatedWork());
            }

            foreach (var dto in request.Attachments)
            {
                builder.AddAttachment(dto.ToAttachment(_mimeTypeMapper.GetMimeType(dto.FileName), now));
            }

            foreach (var tag in request.Tags)
            {
                builder.AddTag(new Tag(tag));
            }

            var bug = builder.BuildWorkItem();

            _uow.BugRepository.Insert(bug);

            if (request.SprintId.HasValue)
            {
                _workItemIntegrationEventService.AddAndSaveEventAsync(
                    new BugCreatedIntegrationEvent(bug.Id, request.OriginalEstimate, request.Remaining,
                                                   request.Completed, request.SprintId.Value));
            }

            return(Task.FromResult(bug.Id));
        }
        public static bool EffortDelete(Effort effort)
        {
            bool ret     = true;
            User curUser = Viola.Models.User.GetCurrentUser();

            // company kontrolü
            if (effort.CompanyId != curUser.CompanyId)
            {
                ret = false;
            }

            // kullanıcılar sadece yetkileri olduğu kişilerin eforlarını silebilir
            // admin: herkesi
            // user: sadece kendisini
            if (!Viola.Models.User.GetUsersForEffort().Where(x => x.Id == effort.UserId).Any())
            {
                ret = false;
            }

            return(ret);
        }
Beispiel #30
0
        // GET: Efforts/Delete/5
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            Effort effort = db.Efforts.Find(id);

            if (effort == null)
            {
                return(HttpNotFound());
            }

            if (!EntityAuthorization.EffortDelete(effort))
            {
                return(HttpNotFound());
            }

            return(View(effort));
        }
Beispiel #31
0
        private Effort CalculateMaxEffort([NotNull] EffortPropertySchemaManager schemaManager)
        {
            Effort result = Effort.Undefined;

            var model        = _mitigation.Model;
            var propertyType = schemaManager.GetPropertyType();

            if (model != null && propertyType != null)
            {
                CalculateMaxEffort(model, propertyType);

                var entities = model.Entities?.ToArray();
                if (entities?.Any() ?? false)
                {
                    foreach (var entity in entities)
                    {
                        var effort = CalculateMaxEffort(entity, propertyType);
                        if (effort > result)
                        {
                            result = effort;
                        }
                    }
                }

                var flows = model.DataFlows?.ToArray();
                if (flows?.Any() ?? false)
                {
                    foreach (var flow in flows)
                    {
                        var effort = CalculateMaxEffort(flow, propertyType);
                        if (effort > result)
                        {
                            result = effort;
                        }
                    }
                }
            }

            return(result);
        }
Beispiel #32
0
        public HttpResponseMessage addUserToTask(string userId, [FromBody] int idEffort)
        {
            try
            {
                using (var unitOfWork = new UnitOfWork(new FoolStaffContext()))
                {
                    User   user         = unitOfWork.Users.Search(u => u.Id == userId).Include(e => e.Efforts).FirstOrDefault();
                    Effort entityEffort = unitOfWork.Efforts.SingleOrDefault(t => t.Id == idEffort);
                    user.Efforts.Add(entityEffort);
                    unitOfWork.Complete();

                    var entity = unitOfWork.Efforts.Search(t => t.Stato == "OPEN").Include(c => c.Users).OrderByDescending(t => t.Priorita).ToList();
                    log.Debug("addUserToTask - utente id [" + unitOfWork.Users.SingleOrDefault(u => u.Id == userId).Id + "] correttamente associato al task");
                    return(Request.CreateResponse(HttpStatusCode.OK, entity));
                }
            }
            catch (Exception ex)
            {
                log.Error("addUserToTask - errore nell'associazione dell'utente al task ", ex);
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
            }
        }
Beispiel #33
0
 public Scheduler(Circuit circuit, Duration duration, Effort effort)
 {
     candidateLevels = new List<Level>();
     BuildCandidates();
     schedule = candidateLevels[0];
     this.circuit = circuit;
     this.duration = duration;
     this.effort = effort;
 }
Beispiel #34
0
 public void Easier()
 {
     effort = effort.PreviousLevel();
 }
Beispiel #35
0
 public void Harder()
 {
     effort = effort.NextLevel();
 }
Beispiel #36
0
        public void ShouldBeComparable()
        {
            var effort1 = new Effort(50);
            var effort2 = new Effort(51);
            var effort3 = new Effort(50);

            Assert.AreEqual(effort1, effort1);
            Assert.AreEqual(effort1, effort3);
            Assert.AreNotEqual(effort1, effort2);
        }
Beispiel #37
0
 public void NormalizedValueShouldBeAvailable()
 {
     var effort = new Effort(75);
     Assert.AreEqual(0.75D, effort.Normalized());
 }
Beispiel #38
0
 public void ShouldBeAvailableAsPercentage()
 {
     const int PERCENTAGE = 75;
     var effort = new Effort(PERCENTAGE);
     Assert.AreEqual(PERCENTAGE, effort.AsPercentage());
 }
Beispiel #39
0
 public void ShouldRejectValueAbove100()
 {
     var effort = new Effort(140);
 }
Beispiel #40
0
 public void ShouldRejectNegativeValue()
 {
     var effort = new Effort(-34);
 }
Beispiel #41
0
 public void ShouldBeSetByDefault()
 {
     var effort = new Effort();
     Assert.IsTrue(effort.IsDefault());
 }
Beispiel #42
0
 public void ShouldBeIncrementable()
 {
     var effort = new Effort(75);
     var newEffort = effort.NextLevel();
     Assert.IsTrue(newEffort.IsHarderThan(effort));
 }
Beispiel #43
0
 public void ShouldBeDecrementable()
 {
     var effort = new Effort(75);
     var newEffort = effort.PreviousLevel();
     Assert.IsTrue(effort.IsHarderThan(newEffort));
 }