public void BecauseOf()
        {
            using (TestDataContext dataContext = new TestDataContext(_connectionString))
            {
                UserDto userDto = new UserDto
                {
                    DisplayName = "TestUserName",
                    Id = _idToUse,
                    Latitude = 1.0M,
                    Longitude = 1.0M,
                    Email = "*****@*****.**",
                    ZoneId = _currentHotZone,
                    Money = 500,
                    Level = 1,
                    BaseLineEnergy = 15,
                    BaseLineAttackPower = 15,
                    PossibleItemAmount = 5
                };

                dataContext.UserDtos.InsertOnSubmit(userDto);
                dataContext.SubmitChanges();

                HotZoneDto hotZoneDto = new HotZoneDto
                {
                    CanStartHere = false,
                    Id = _newHotZoneIdToUse,
                    Latitude = (decimal)_newHotZoneLatitude,
                    Longitude = (decimal)_newHotZoneLongitude,
                    Name = "New Test HotZone"
                };

                dataContext.HotZoneDtos.InsertOnSubmit(hotZoneDto);
                dataContext.SubmitChanges();
            }
        }
        public void should_not_insert_empty_record_for_user_if_non_exists()
        {
            long miles = _userStatsRetriever.GetStats(_nonExistantUserId).MilesTraveled;
            Assert.AreEqual(0, miles);

            TestDataContext testDataContext = new TestDataContext(_connectionString);
            Assert.IsFalse(testDataContext.UserCountDtos.Any(s => s.UserId == _nonExistantUserId));
        }
 private UserCountDto TheCountsForUser(Guid _userId)
 {
     using (TestDataContext testDataContext = new TestDataContext(_connectionString))
     {
         UserCountDto userCountDto = testDataContext.UserCountDtos.Single(s => s.UserId == _userId);
         return userCountDto;
     }
 }
 public void TestCleanup()
 {
     TestDataContext testDataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
     if (testDataContext.UserDtos.Any(s => s.FacebookUserId == _facebookUserId))
     {
         testDataContext.UserDtos.DeleteOnSubmit(testDataContext.UserDtos.Single(s => s.FacebookUserId == _facebookUserId));
         testDataContext.SubmitChanges();
     }
 }
        public void should_save_user_max_energy()
        {
            _userSaver.SetCurrentBaseSightRadius(_userId, 300);
            TestDataContext dataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
            var dto = dataContext.UserDtos
                                 .Single(u => u.Id == _userId);

            Assert.AreEqual(300, dto.BaseSightRadius);
        }
 public void TestCleanup()
 {
     TestDataContext dataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
     dataContext.UserDtos
                .DeleteAllOnSubmit(
                     dataContext.UserDtos
                                .Where(u => u.Id == _userId));
     dataContext.SubmitChanges();
 }
        public void should_save_user_sight_radius()
        {
            _userSaver.SaveLastSightRadius(_userId, 20, DateTime.Today);
            TestDataContext dataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
            var dto = dataContext.UserDtos
                                 .Single(u => u.Id == _userId);

            Assert.AreEqual(20, dto.LastSightRadius);
            Assert.AreEqual(DateTime.Today, dto.LastSightRadiusDate);
        }
        public void TestCleanup()
        {
            using (TestDataContext dataContext = new TestDataContext(_connectionString))
            {
                dataContext.UserZombiePackProgressDtos.DeleteAllOnSubmit(
                                dataContext.UserZombiePackProgressDtos.Where(c => c.UserId == _userId));

                dataContext.SubmitChanges();
            }
        }
        public void BecauseOf()
        {
            using (TestDataContext dataContext = new TestDataContext(_connectionString))
            {
                List<StoreDto> storeDtos = new List<StoreDto>();

                storeDtos.Add(new StoreDto
                {
                    Id = _storeId1,
                    Latitude = (decimal)_latitude1,
                    Longitude = (decimal)_longitude1,
                    Name = _name1,
                    HotZoneId = _hotZoneId
                });

                storeDtos.Add(new StoreDto
                {
                    Id = _storeId2,
                    Latitude = (decimal)_latitude2,
                    Longitude = (decimal)_longitude2,
                    Name = _name2,
                    HotZoneId = _hotZoneId
                });

                storeDtos.Add(new StoreDto
                {
                    Id = _storeId3,
                    Latitude = (decimal)_latitude3,
                    Longitude = (decimal)_longitude3,
                    Name = _name3,
                    HotZoneId = _hotZoneId
                });

                dataContext.StoreDtos.InsertAllOnSubmit(storeDtos);

                List<ItemDto> itemDtos = new List<ItemDto>();

                itemDtos.Add(new ItemDto
                {
                    Description = _itemDescription1,
                    Distance = _itemDistance1,
                    Energy = _itemEnergy1,
                    Id = _itemId1,
                    Name = _itemName1,
                    Price = _itemPrice1
                });

                dataContext.ItemDtos.InsertAllOnSubmit(itemDtos);

                dataContext.SubmitChanges();

                _storeCount = dataContext.StoreDtos.Count();
                _itemCount = dataContext.ItemDtos.Count();
            }
        }
        public void TestCleanup()
        {
            TestDataContext testDataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
            testDataContext.HotZoneDtos.DeleteAllOnSubmit(testDataContext.HotZoneDtos.Where(h => _hotZonesIds.Contains(h.Id)));
            testDataContext.SubmitChanges();
            testDataContext.ZombiePackDtos.DeleteAllOnSubmit(testDataContext.ZombiePackDtos.Where(z => _zombiePackIds.Contains(z.Id)));
            testDataContext.SubmitChanges();
            testDataContext.UserZombiePackProgressDtos.DeleteAllOnSubmit(testDataContext.UserZombiePackProgressDtos.Where(z => _zombiePackIds.Contains(z.ZombiePackId)));
            testDataContext.SubmitChanges();
            testDataContext.UserDtos.DeleteAllOnSubmit(testDataContext.UserDtos.Where(u => _userIds.Contains(u.Id)));
            testDataContext.SubmitChanges();

        }
        public void CleanUp()
        {
            using (TestDataContext dataContext = new TestDataContext(_connectionString))
            {
                dataContext.UserDtos.DeleteAllOnSubmit(
                                dataContext.UserDtos.Where(c => c.Id == _idToUse));

                dataContext.HotZoneDtos.DeleteAllOnSubmit(
                                dataContext.HotZoneDtos.Where(c => c.Id == _newHotZoneIdToUse));

                dataContext.SubmitChanges();
            }
        }
 public void should_insert_zombie_pack_progress_that_does_exist()
 {
     UserZombiePackProgress progress = new UserZombiePackProgress { MaxZombies = 100, IsDestroyed = true, ZombiesLeft = 25 };
     _userZombiePackProgressSaver.SaveZombiePackProgress(_userId, _zombiePackId, progress);
     using (TestDataContext dataContext = new TestDataContext(_connectionString))
     {
         var dto = dataContext.UserZombiePackProgressDtos.Single(s => s.UserId == _userId && s.ZombiePackId == _zombiePackId);
         Assert.AreEqual(_userId, dto.UserId);
         Assert.AreEqual(_zombiePackId, dto.ZombiePackId);
         Assert.AreEqual(100, dto.MaxZombies);
         Assert.AreEqual(25, dto.ZombiesLeft);
         Assert.AreEqual(true, dto.IsDestroyed);
     }
 }
        public void TestInitialize()
        {
            TestDataContext dataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
            ZombiePackDto dto = new ZombiePackDto
            {
                Id = _zombiePackId,
                HotZoneId = Guid.NewGuid(),
                Latitude = 0,
                Longitude = 0,
                Name = string.Empty
            };

            dataContext.ZombiePackDtos.InsertOnSubmit(dto);
            dataContext.SubmitChanges();
        }
        public void BeacauseOf()
        {
            using (TestDataContext dataConext = new TestDataContext(_connectionString))
            {
                List<UserDto> userDtos = new List<UserDto>();
                userDtos.Add(new UserDto
                            {
                                DisplayName = _displayName,
                                Email = _email,
                                Id = _idToUse,
                                Latitude = (decimal)_lattitude,
                                LocationId = _locationIdToUse,
                                Longitude = (decimal)_longitude,
                                ZoneId = _zoneIdToUse,
                                Money = _money,
                                LastVisitedHotZoneId = _lastVisitedHotZoneId,
                                BaseLineAttackPower = 1,
                                BaseLineEnergy = 100,
                                Level = 5,
                                PossibleItemAmount = _possibleItemAmount1,
                                CurrentBaseAttack = 1,
                                CurrentBaseEnergy = 100,
                                FacebookUserId = 200
                            });

                userDtos.Add(new UserDto
                            {
                                DisplayName = _displayName2,
                                Email = _email2,
                                Id = _idToUse2,
                                Latitude = (decimal)_lattitude2,
                                LocationId = _locationIdToUse2,
                                Longitude = (decimal)_longitude2,
                                ZoneId = _zoneIdToUse2,
                                BaseLineAttackPower = 1,
                                BaseLineEnergy = 100,
                                Money = _money2,
                                PossibleItemAmount = _possibleItemAmount2
                            });

                dataConext.UserDtos.InsertAllOnSubmit(userDtos);
                dataConext.SubmitChanges();
                        
            }
        }
        public void TestInitialize()
        {
            TestDataContext dataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
            UserDto userDto = new UserDto
            {
                Id = _userId,
                DisplayName = "name",
                Email = "email",
                Latitude = 0,
                LocationId = Guid.NewGuid(),
                Longitude = 0,
                ZoneId = Guid.NewGuid()
            };

            dataContext.UserDtos.InsertOnSubmit(userDto);

            dataContext.SubmitChanges();
        }
        private Guid GivenHotZone(string name)
        {
            TestDataContext testDataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
            Guid hotZoneId = Guid.NewGuid();
            HotZoneDto hotZoneDto = new HotZoneDto
            {
                Id = hotZoneId,
                CanStartHere = false,
                Latitude = 0,
                Longitude = 0,
                Name = name
            };

            _hotZonesIds.Add(hotZoneId);

            testDataContext.HotZoneDtos.InsertOnSubmit(hotZoneDto);
            testDataContext.SubmitChanges();

            return hotZoneId;
        }
        public void should_update_existing_zombie_pack_progress()
        {
            UserZombiePackProgress progress = new UserZombiePackProgress { MaxZombies = 100, IsDestroyed = true, ZombiesLeft = 25 };
            _userZombiePackProgressSaver.SaveZombiePackProgress(_userId, _zombiePackId, progress);

            //update
            progress.ZombiesLeft = 10;
            progress.MaxZombies = 20;
            progress.IsDestroyed = false;
            _userZombiePackProgressSaver.SaveZombiePackProgress(_userId, _zombiePackId, progress);

            using (TestDataContext dataContext = new TestDataContext(_connectionString))
            {
                var dto = dataContext.UserZombiePackProgressDtos.Single(s => s.UserId == _userId && s.ZombiePackId == _zombiePackId);
                Assert.AreEqual(_userId, dto.UserId);
                Assert.AreEqual(_zombiePackId, dto.ZombiePackId);
                Assert.AreEqual(20, dto.MaxZombies);
                Assert.AreEqual(10, dto.ZombiesLeft);
                Assert.AreEqual(false, dto.IsDestroyed);
            }
        }
        public void TestInitialize()
        {
            TestDataContext testDataContext = new TestDataContext(_connectionString);
            var userCountDto = new UserCountDto
            {
                Id = Guid.NewGuid(),
                HotZonesDestroyed = 10,
                Miles = 11,
                UserId = _userId,
                PeakAttack = 111,
                ZombiesKilled = 1111,
                ZombiePacksDestroyed = 11111,
                AccumulatedMoney = 500
            };

            testDataContext.UserCountDtos.InsertOnSubmit(userCountDto);
            testDataContext.SubmitChanges();

            UserDto userDto = new UserDto { Id = _userId, DisplayName = "name", Email = string.Empty };
            testDataContext.UserDtos.InsertOnSubmit(userDto);
            testDataContext.SubmitChanges();
        }
        public void BecauseOf()
        {
            using (TestDataContext dataContext = new TestDataContext(_connectionString))
            {
                List<HotZoneDto> hotZoneDtos = new List<HotZoneDto>();
                hotZoneDtos.Add(new HotZoneDto
                {
                    Id = _hotZoneId,
                    Latitude = (decimal)_latitudeToUse,
                    Longitude = (decimal)_longitudeToUse,
                    Name = "Hot Zone"
                });

                dataContext.HotZoneDtos.InsertAllOnSubmit(hotZoneDtos);
                dataContext.SubmitChanges();

                List<ZombiePackDto> zombiePackDtos = new List<ZombiePackDto>();
                zombiePackDtos.Add(new ZombiePackDto
                {
                    HotZoneId = _hotZoneId,
                    Id = _zombiePackId,
                    Latitude = (decimal)_latitudeToUse,
                    Longitude = (decimal)_longitudeToUse,
                    Name = "Zombie Pack1"
                });

                zombiePackDtos.Add(new ZombiePackDto
                {
                    HotZoneId = _hotZoneId,
                    Id = _zombiePackId2,
                    Latitude = (decimal)_latitudeToUse2,
                    Longitude = (decimal)_longitudeToUse2,
                    Name = "Zombie Pack2"
                });

                dataContext.ZombiePackDtos.InsertAllOnSubmit(zombiePackDtos);
                dataContext.SubmitChanges();
            }
        }
        public void TestInitialize()
        {
            TestDataContext dataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
            UserDto userDto = new UserDto
            {
                Id = _populatedUserId,
                DisplayName = "name",
                Email = "email",
                LastEnergy = 50,
                LastEnergyDate = DateTime.Today,
                Latitude = 0,
                LocationId = Guid.NewGuid(),
                Longitude = 0,
                BaseLineEnergy = 100,
                ZoneId = Guid.NewGuid()
            };

            dataContext.UserDtos.InsertOnSubmit(userDto);

            userDto = new UserDto
            {
                Id = _emptyUserId,
                DisplayName = "name",
                Email = "email",
                LastEnergy = null,
                LastEnergyDate = null,
                Latitude = 0,
                LocationId = Guid.NewGuid(),
                Longitude = 0,
                BaseLineEnergy = 0,
                ZoneId = Guid.NewGuid()
            };

            dataContext.UserDtos.InsertOnSubmit(userDto);

            dataContext.SubmitChanges();
        }
        private void GivenUser(int withFacebookId, int level, string name, long killed = 0, long miles = 0, long packs = 0, long hotzones = 0, long money = 0, long streak = 0)
        {
            TestDataContext testDataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
            Guid userId = Guid.NewGuid();
            UserDto userDto = new UserDto
            {
                Id = userId,
                BaseLineAttackPower = 0,
                BaseLineEnergy = 0,
                CurrentBaseAttack = 0,
                CurrentBaseEnergy = 0,
                DisplayName = name,
                Email = string.Empty,
                FacebookUserId = withFacebookId,
                Latitude = 0,
                Level = level,
                ZoneId = Guid.Empty
            };

            testDataContext.UserDtos.InsertOnSubmit(userDto);
            testDataContext.SubmitChanges();

            UserCountDto userCountDto = new UserCountDto
            {
                AccumulatedMoney = money,
                HotZonesDestroyed = hotzones,
                Id = Guid.NewGuid(),
                Miles = miles,
                PeakAttack = streak,
                UserId = userId,
                ZombiePacksDestroyed = packs,
                ZombiesKilled = killed
            };

            testDataContext.UserCountDtos.InsertOnSubmit(userCountDto);
            testDataContext.SubmitChanges();

            _userIds.Add(userId);
        }
        public void TestCleanup()
        {
            TestDataContext testDataContext = new TestDataContext(DalTestContextSpecification.ConnectionString);
            testDataContext.UserCountDtos.DeleteAllOnSubmit(testDataContext.UserCountDtos.Where(s => _userIds.Contains(s.UserId.Value)));
            testDataContext.SubmitChanges();

            testDataContext.UserDtos.DeleteAllOnSubmit(testDataContext.UserDtos.Where(s => _userIds.Contains(s.Id)));
            testDataContext.SubmitChanges();
        }
        public void should_update_user_location_if_user_exists()
        {
            _userSaver.UpdateUserLocation(_idToUse, 2.0, 2.0);

            using (TestDataContext dataContext = new TestDataContext(_connectionString))
            {
                UserDto user = dataContext.UserDtos.SingleOrDefault(c => c.Id == _idToUse);

                Assert.AreEqual(_idToUse, user.Id);
                Assert.AreEqual((decimal)2.0, user.Latitude);
                Assert.AreEqual((decimal)2.0, user.Longitude);
            }
        }
 public void should_set_user_current_base_energy()
 {
     _userSaver.UpdateCurrentBaseEnergy(_idToUse, 20);
     using (TestDataContext dataContext = new TestDataContext(_connectionString))
     {
         UserDto userDto = dataContext.UserDtos.SingleOrDefault(c => c.Id == _idToUse);
         Assert.AreEqual(20, userDto.CurrentBaseEnergy);
     }
 }
 public void should_update_users_inventory_amount()
 {
     _userSaver.UpdateUserInventorySlot(_idToUse, 10);
     using (TestDataContext dataContext = new TestDataContext(_connectionString))
     {
         UserDto userDto = dataContext.UserDtos.SingleOrDefault(c => c.Id == _idToUse);
         Assert.AreEqual(10, userDto.PossibleItemAmount);
     }
 }
 public void should_update_users_base_attack()
 {
     _userSaver.UpdateAttackForDifficultyCalculation(_idToUse, 50);
     using (TestDataContext dataContext = new TestDataContext(_connectionString))
     {
         UserDto userDto = dataContext.UserDtos.SingleOrDefault(c => c.Id == _idToUse);
         Assert.AreEqual(50, userDto.BaseLineAttackPower);
     }
 }
 public void should_set_user_level()
 {
     _userSaver.SetUserLevel(_idToUse, 2);
     using (TestDataContext dataContext = new TestDataContext(_connectionString))
     {
         UserDto userDto = dataContext.UserDtos.SingleOrDefault(c => c.Id == _idToUse);
         Assert.AreEqual(2, userDto.Level);
     }
 }
 public void should_update_baseline_attack_power_for_user()
 {
     _userSaver.UpdateBaseLine(_idToUse, 1000, 1200);
     using (TestDataContext dataContext = new TestDataContext(_connectionString))
     {
         UserDto userDto = dataContext.UserDtos.SingleOrDefault(c => c.Id == _idToUse);
         Assert.AreEqual(userDto.BaseLineAttackPower, 1000);
         Assert.AreEqual(userDto.BaseLineEnergy, 1200);
     }
 }
        public void should_update_last_visited_hotzone_for_user()
        {
            Guid hotZoneId = Guid.NewGuid();
            _userSaver.UpdateLastVisitedHotZone(_idToUse, hotZoneId);

            using (TestDataContext dataContext = new TestDataContext(_connectionString))
            {
                UserDto userDto = dataContext.UserDtos.SingleOrDefault(c => c.Id == _idToUse);
                Assert.AreEqual(userDto.LastVisitedHotZoneId, hotZoneId);
            }
        }
        public void should_add_money_passed_in_to_money_of_the_current_user()
        {
            //users by default start off with 500 money (db constraint).
            _userSaver.AddMoney(_idToUse, 100);

            using (TestDataContext dataContext = new TestDataContext(_connectionString))
            {
                UserDto userDto = dataContext.UserDtos.SingleOrDefault(c => c.Id == _idToUse);

                Assert.AreEqual(600, userDto.Money);
            }
        }