public void GetAllowedTimeReturnSavedTimeWhenRemainingTimeLessThenMaxAllowedTime()
        {
            var expectedTime = TimeSpan.FromMilliseconds(Locktimer.GetMaxAllowedTime().TotalMilliseconds / 2);

            LastSessionSynchronizer.SaveSessionData(expectedTime);

            var allowedTime = LastSessionSynchronizer.GetAllowedTime();

            Assert.AreEqual(expectedTime, allowedTime);
        }
        public void SaveSessionDataSaveCorrectDate()
        {
            LastSessionSynchronizer.SaveSessionData(TimeSpan.FromHours(2));
            DateTime savedDate;

            using (var lastSessionDataFile = new StreamReader(LastSessionSynchronizer.LAST_SESSION_DATA_WAY))
                savedDate = DateTime.Parse(lastSessionDataFile.ReadLine());

            Assert.AreEqual(DateTime.Now.Date, savedDate);
        }
        public void GetAllowedTimeReturnMaxAllowedTimeWhenRemainingTimeLargerThenMaxAllowedTime()
        {
            TimeSpan savingTime = Locktimer.GetMaxAllowedTime() + TimeSpan.FromMinutes(30);

            LastSessionSynchronizer.SaveSessionData(savingTime);

            var allowedTime    = LastSessionSynchronizer.GetAllowedTime();
            var maxAllowedTime = Locktimer.GetMaxAllowedTime();

            Assert.AreEqual(maxAllowedTime, allowedTime);
        }
Exemple #4
0
        public void RemainingTimeReturnTimeThatIsNotLargerThanMaxAllowedTime()
        {
            LastSessionSynchronizer.SaveSessionData(TimeSpan.FromHours(25));
            var windowsLocker = new WindowsLocker();
            var locktimer     = new Locktimer(windowsLocker);

            var remainingTime  = locktimer.GetRemainingTime();
            var maxAllowedTime = Locktimer.GetMaxAllowedTime();
            var remainingTimeIsNotLargerThanMaxAllowedTime = remainingTime <= maxAllowedTime;

            Assert.AreEqual(true, remainingTimeIsNotLargerThanMaxAllowedTime);
        }
        public void GetAllowedTimeReturnMaxAllowedTimeWhenFileNotExists()
        {
            if (File.Exists(LastSessionSynchronizer.LAST_SESSION_DATA_WAY))
            {
                File.Delete(LastSessionSynchronizer.LAST_SESSION_DATA_WAY);
            }

            var allowedTime    = LastSessionSynchronizer.GetAllowedTime();
            var maxAllowedTime = Locktimer.GetMaxAllowedTime();

            Assert.AreEqual(maxAllowedTime, allowedTime);
        }
        public void SaveSessionDataCreateFile()
        {
            if (File.Exists(LastSessionSynchronizer.LAST_SESSION_DATA_WAY))
            {
                File.Delete(LastSessionSynchronizer.LAST_SESSION_DATA_WAY);
            }

            LastSessionSynchronizer.SaveSessionData(TimeSpan.FromHours(2));
            var fileExists = File.Exists(LastSessionSynchronizer.LAST_SESSION_DATA_WAY);

            Assert.AreEqual(true, fileExists);
        }
        public void GetAllowedTimeReturnMaxAllowedTimeWhenSavedDateLessThanCurrentDate()
        {
            var notExpectedTime = TimeSpan.FromMilliseconds(Locktimer.GetMaxAllowedTime().TotalMilliseconds / 2);

            using (var sessionData = new StreamWriter(LastSessionSynchronizer.LAST_SESSION_DATA_WAY, false))
            {
                sessionData.WriteLine(DateTime.Now.Subtract(TimeSpan.FromDays(1)).Date.ToString());
                sessionData.WriteLine(notExpectedTime.ToString(@"hh\:mm\:ss"));
            }

            var allowedTime    = LastSessionSynchronizer.GetAllowedTime();
            var maxAllowedTime = Locktimer.GetMaxAllowedTime();

            Assert.AreEqual(maxAllowedTime, allowedTime);
        }
        public void SaveSessionDataSaveCorrectRemainingTime()
        {
            var expectedTime = TimeSpan.FromHours(2);

            LastSessionSynchronizer.SaveSessionData(expectedTime);
            TimeSpan savedTime;

            using (var lastSessionDataFile = new StreamReader(LastSessionSynchronizer.LAST_SESSION_DATA_WAY))
            {
                lastSessionDataFile.ReadLine();
                savedTime = TimeSpan.Parse(lastSessionDataFile.ReadLine());
            }

            Assert.AreEqual(expectedTime, savedTime);
        }