public SubscriptionSettingsServiceTests()
{
var fakeDbContext = new FakeLikkleDbContext().Seed();
this._mockedLikkleUoW = new Mock <ILikkleUoW>();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository)
.Returns(new AreaRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository)
.Returns(new UserRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository)
.Returns(new GroupRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.TagRepository)
.Returns(new TagRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.LanguageRepository)
.Returns(new LanguageRepository(fakeDbContext));
this._mockedConfigurationProvider = new Mock <IConfigurationProvider>();
this._subscriptionSettingsService = new SubscriptionSettingsService(
this._mockedLikkleUoW.Object,
this._mockedConfigurationProvider.Object);
}
public void StandaloneGroup_We_Create_Gets_Into_Our_HistoryGroups()
{
// arrange
var userId = Guid.NewGuid();
var dbUser = new User()
{
Id = userId,
AutomaticSubscriptionSettings = null
};
var newAreaId = Guid.NewGuid();
var newArea = new Area()
{
Id = newAreaId,
Latitude = 10,
Longitude = 10,
Radius = RadiusRangeEnum.FiftyMeters
};
var populatedDatabase = new FakeLikkleDbContext()
{
Users = new FakeDbSet <User>()
{
dbUser
},
Areas = new FakeDbSet <Area>()
{
newArea
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.TagRepository).Returns(new TagRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
var newGroupRequest = new StandaloneGroupRequestDto()
{
Name = "New group",
TagIds = new List <Guid>()
{
Guid.Parse("caf77dee-a94f-49cb-b51f-e0c0e1067541"), Guid.Parse("bd456f08-f137-4382-8358-d52772c2dfc8")
},
AreaIds = new List <Guid>()
{
newAreaId
},
UserId = userId
};
// act
var newGroupId = this._groupService.InsertNewGroup(newGroupRequest);
// assert
var user = this._mockedLikkleUoW.Object.UserRepository.GetUserById(userId);
Assert.IsNotNull(user.HistoryGroups);
Assert.IsTrue(user.HistoryGroups.Select(hg => hg.GroupId).Contains(newGroupId));
}
public void We_Can_Get_User_By_StsId()
{
// arrange
var idsrvUniqueId = Guid.NewGuid().ToString();
var firstUser = new User()
{
Id = Guid.NewGuid(),
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = idsrvUniqueId,
AutomaticSubscriptionSettings = new AutomaticSubscriptionSetting()
{
AutomaticallySubscribeToAllGroups = false,
AutomaticallySubscribeToAllGroupsWithTag = false
}
};
var populatedDatabase = new FakeLikkleDbContext()
{
Users = new FakeDbSet <User>()
{
firstUser
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
// act
var user = this._userService.GetUserByStsId(idsrvUniqueId);
// assert
Assert.IsNotNull(user);
}
public UserServiceTests()
{
var fakeDbContext = new FakeLikkleDbContext().Seed();
this._mockedLikkleUoW = new Mock <ILikkleUoW>();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository)
.Returns(new AreaRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository)
.Returns(new UserRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository)
.Returns(new GroupRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.TagRepository)
.Returns(new TagRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.LanguageRepository)
.Returns(new LanguageRepository(fakeDbContext));
this._accelometerAlgorithmHelperService = new Mock <IAccelometerAlgorithmHelperService>();
this._accelometerAlgorithmHelperService.Setup(
a => a.SecondsToClosestBoundary(It.IsAny <double>(), It.IsAny <double>())).Returns(32.5);
this._subscriptionSettingsServiceMock = new Mock <ISubscriptionSettingsService>();
this._mockedConfigurationProvider = new Mock <IConfigurationProvider>();
var mapConfiguration = new MapperConfiguration(cfg => {
cfg.AddProfile <EntitiesMappingProfile>();
});
this._mockedConfigurationProvider.Setup(mc => mc.CreateMapper()).Returns(mapConfiguration.CreateMapper);
this._subscriptionSettingsService = new SubscriptionSettingsService(
this._mockedLikkleUoW.Object,
this._mockedConfigurationProvider.Object);
this._configurationWrapperMock = new Mock <IConfigurationWrapper>();
// Only this call to the mocked service returns the actual result but not mocked one.
this._subscriptionSettingsServiceMock
.Setup(ss => ss.GroupsForUserAroundCoordinatesBasedOnUserSettings(It.IsAny <Guid>(), It.IsAny <double>(), It.IsAny <double>()))
.Returns((Guid userId, double lat, double lon) => this._subscriptionSettingsService.GroupsForUserAroundCoordinatesBasedOnUserSettings(userId, lat, lon));
this._userService = new UserService(
this._mockedLikkleUoW.Object,
this._mockedConfigurationProvider.Object,
this._configurationWrapperMock.Object,
this._accelometerAlgorithmHelperService.Object,
this._subscriptionSettingsServiceMock.Object);
this._subscriptionService = new SubscriptionService(
this._mockedLikkleUoW.Object,
this._mockedConfigurationProvider.Object,
this._configurationWrapperMock.Object);
}
public static void SetupAreaUserAndGroupRepositories(
Mock <ILikkleUoW> uowMock,
FakeLikkleDbContext fakeContext)
{
uowMock.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(fakeContext));
uowMock.Setup(uow => uow.UserRepository).Returns(new UserRepository(fakeContext));
uowMock.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(fakeContext));
}
public void We_Can_Get_Areas_Inside_Of_Which_We_Are()
{
// arrange
var firstAreaId = Guid.NewGuid();
var firstArea = new Area()
{
Id = firstAreaId,
Latitude = 10,
Longitude = 10,
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true
};
var secondAreaId = Guid.NewGuid();
var secondArea = new Area()
{
Id = secondAreaId,
Latitude = 10,
Longitude = 10,
Radius = RadiusRangeEnum.ThreeHundredMeters,
IsActive = true
};
var thirdAreaId = Guid.NewGuid();
var thirdArea = new Area()
{
Id = thirdAreaId,
Latitude = 50,
Longitude = 50,
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true
};
var populatedDatabase = new FakeLikkleDbContext()
{
Areas = new FakeDbSet <Area>()
{
firstArea, secondArea, thirdArea
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
// act
var areasWhereWeFallIn = this._areaService.GetAreas(10, 10);
// assert
Assert.IsNotNull(areasWhereWeFallIn);
Assert.AreEqual(areasWhereWeFallIn.Count(), 2);
var areaIds = areasWhereWeFallIn.Select(a => a.Id);
Assert.IsTrue(areaIds.Contains(firstAreaId));
Assert.IsTrue(areaIds.Contains(secondAreaId));
Assert.IsFalse(areaIds.Contains(thirdAreaId));
}
public void We_Can_Get_Areas_In_A_Radius_Of_Certain_Point()
{
// arrange
var firstAreaId = Guid.NewGuid();
var firstArea = new Area()
{
Id = firstAreaId,
Latitude = 10,
Longitude = 10,
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true
};
var secondAreaId = Guid.NewGuid();
var secondArea = new Area()
{
Id = secondAreaId,
Latitude = 10.000001,
Longitude = 10.000001,
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true
};
var thirdAreaId = Guid.NewGuid();
var thirdArea = new Area()
{
Id = thirdAreaId,
Latitude = 42,
Longitude = 42,
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true
};
var populatedDatabase = new FakeLikkleDbContext()
{
Areas = new FakeDbSet <Area>()
{
firstArea, secondArea, thirdArea
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
// act
var areasAroundCoordinatesInRadius = this._areaService.GetAreas(10, 10, 10);
// assert
Assert.IsNotNull(areasAroundCoordinatesInRadius);
Assert.AreEqual(areasAroundCoordinatesInRadius.Count(), 2);
var areaIds = areasAroundCoordinatesInRadius.Select(a => a.Id);
Assert.IsTrue(areaIds.Contains(firstAreaId));
Assert.IsTrue(areaIds.Contains(secondAreaId));
Assert.IsFalse(areaIds.Contains(thirdAreaId));
}
public void We_Can_Insert_Grou_As_New_Area()
{
// arrange
var userId = Guid.NewGuid();
var dbUser = new User()
{
Id = userId,
AutomaticSubscriptionSettings = null
};
var populatedDatabase = new FakeLikkleDbContext()
{
Users = new FakeDbSet <User>()
{
dbUser
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.TagRepository).Returns(new TagRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
var newGroupRequest = new GroupAsNewAreaRequestDto()
{
Longitude = 10,
Latitude = 10,
Name = "Group 1",
Radius = RadiusRangeEnum.FiftyMeters,
TagIds =
new List <Guid>()
{
Guid.Parse("caf77dee-a94f-49cb-b51f-e0c0e1067541"),
Guid.Parse("bd456f08-f137-4382-8358-d52772c2dfc8")
},
UserId = userId
};
var allAreasCount = this._areaService.GetAllAreas().Count();
Assert.AreEqual(allAreasCount, 0);
// act
var newGroupId = this._groupService.InserGroupAsNewArea(newGroupRequest);
// assert
allAreasCount = this._areaService.GetAllAreas().Count();
Assert.AreNotEqual(newGroupId, Guid.Empty);
Assert.AreEqual(allAreasCount, 1);
var newlyCreatedGroup = this._groupService.GetGroupById(newGroupId);
Assert.IsNotNull(newlyCreatedGroup);
}
public AccelometerAlgorithmHelperServiceTests()
{
var fakeDbContext = new FakeLikkleDbContext().Seed();
this._mockedLikkleUoW = new Mock <ILikkleUoW>();
this._configurationWrapperMock = new Mock <IConfigurationWrapper>();
this._configurationWrapperMock.Setup(x => x.PersonWalkingSpeedInKmh).Returns(5);
this._accelometerAlgorithmHelperService = new AccelometerAlgorithmHelperService(
this._mockedLikkleUoW.Object,
this._configurationWrapperMock.Object);
}
public void We_Can_Fetch_All_Users_From_Group()
{
// arrange
var firstUserId = Guid.NewGuid();
var firstUser = new User()
{
Id = firstUserId,
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var secondUserId = Guid.NewGuid();
var secondUser = new User()
{
Id = secondUserId,
FirstName = "Other",
LastName = "Name",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var groupId = Guid.NewGuid();
var group = new Group()
{
Id = groupId, Name = "Group", Users = new List <User>()
{
firstUser, secondUser
}
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
group
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
// act
var allUsersInGroup = this._groupService.GetUsersFromGroup(groupId);
// assert
Assert.IsNotNull(allUsersInGroup);
Assert.AreEqual(allUsersInGroup.Count(), 2);
}
public AreaServiceTests()
{
var fakeDbContext = new FakeLikkleDbContext().Seed();
this._mockedLikkleUoW = new Mock <ILikkleUoW>();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository)
.Returns(new AreaRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository)
.Returns(new UserRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository)
.Returns(new GroupRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.TagRepository)
.Returns(new TagRepository(fakeDbContext));
this._mockedLikkleUoW.Setup(uow => uow.LanguageRepository)
.Returns(new LanguageRepository(fakeDbContext));
this._mockedConfigurationProvider = new Mock <IConfigurationProvider>();
_geoCodingManagerMock = new Mock <IGeoCodingManager>();
_geoCodingManagerMock.Setup(gcm => gcm.GetApproximateAddress(It.IsAny <NewAreaRequest>()))
.Returns(Guid.NewGuid().ToString);
var mapConfiguration = new MapperConfiguration(cfg => {
cfg.AddProfile <EntitiesMappingProfile>();
});
this._mockedConfigurationProvider.Setup(mc => mc.CreateMapper()).Returns(mapConfiguration.CreateMapper);
this._configurationWrapperMock = new Mock <IConfigurationWrapper>();
this._areaService = new AreaService(
this._mockedLikkleUoW.Object,
this._mockedConfigurationProvider.Object,
this._configurationWrapperMock.Object,
this._geoCodingManagerMock.Object);
this._groupService = new GroupService(
this._mockedLikkleUoW.Object,
this._mockedConfigurationProvider.Object,
this._configurationWrapperMock.Object,
this._geoCodingManagerMock.Object);
}
public void We_Get_AutomaticallyGroupAsNewArea_Response_When_Never_Created_Or_Subscribed_Group_Here()
{
// arrange
var userId = Guid.NewGuid();
var dbUser = new User()
{
Id = userId,
AutomaticSubscriptionSettings = null
};
var newAreaId = Guid.NewGuid();
var newArea = new Area()
{
Id = newAreaId,
Latitude = 10,
Longitude = 10,
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true
};
var populatedDatabase = new FakeLikkleDbContext()
{
Users = new FakeDbSet <User>()
{
dbUser
},
Areas = new FakeDbSet <Area>()
{
newArea
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.TagRepository).Returns(new TagRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
// act
var result = this._groupService.GetGroupCreationType(20, 20, userId);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(result.CreationType, CreateGroupActionTypeEnum.AutomaticallyGroupAsNewArea);
}
public void We_Can_Get_All_Users()
{
// arrange
var firstUserId = Guid.NewGuid();
var firstUser = new User()
{
Id = firstUserId,
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var secondUserId = Guid.NewGuid();
var secondUser = new User()
{
Id = secondUserId,
FirstName = "Other",
LastName = "Name",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var populatedDatabase = new FakeLikkleDbContext()
{
Users = new FakeDbSet <User>()
{
firstUser, secondUser
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
// act
var users = this._userService.GetAllUsers();
// assert
Assert.IsNotNull(users);
Assert.IsTrue(users.Count() == 2);
}
public void We_Can_Get_Seconds_To_Closest_Boundary()
{
// arrange
var smallAreaId = Guid.NewGuid();
var smallArea = new Area()
{
Id = smallAreaId,
Latitude = 42.626229,
Longitude = 23.38143,
IsActive = true,
Radius = RadiusRangeEnum.FiftyMeters
};
var biggerAreaId = Guid.NewGuid();
var biggerArea = new Area()
{
Id = biggerAreaId,
Latitude = 42.62523,
Longitude = 23.381371,
IsActive = true,
Radius = RadiusRangeEnum.FiveHundredMeters
};
var populatedDatabase = new FakeLikkleDbContext()
{
Areas = new FakeDbSet <Area>()
{
smallArea, biggerArea
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
// act
var secondsToClosestBoundary = this._accelometerAlgorithmHelperService.SecondsToClosestBoundary(42.626391, 23.381071);
// assert
Assert.AreEqual(11.17049703433503, secondsToClosestBoundary);
}
public void Exception_Is_Thrown_When_Trying_To_Update_Not_Existing_Notification()
{
// arrange
var userId = Guid.NewGuid();
var dbUser = new User()
{
Id = userId,
AutomaticSubscriptionSettings = null
};
var populatedDatabase = new FakeLikkleDbContext()
{
Users = new FakeDbSet <User>()
{
dbUser
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
// act
this._userService.UpdateUserAutomaticSubscriptionSettings(userId, null);
}
public void HistoryGroups_And_RegularGroups_Are_Correct_When_Updating_Location_With_SubscribeToAllWithTagOption_TurnedOn()
{
var allTags = this._mockedLikkleUoW.Object.TagRepository.GetAllTags().ToList();
// arrange
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
AutomaticSubscriptionSettings = new AutomaticSubscriptionSetting()
{
AutomaticallySubscribeToAllGroups = false,
AutomaticallySubscribeToAllGroupsWithTag = true,
Tags = allTags.Where(t => t.Name == "Sport" || t.Name == "Help").ToList()
}
};
// ================= Area1 (GR1, GR2) ========
var groupOneId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId,
Name = "Group one",
IsActive = true,
Tags = new List <Tag>()
{
allTags.FirstOrDefault(t => t.Name == "Animals")
}
};
var groupTwoId = Guid.NewGuid();
var groupTwo = new Group()
{
Id = groupTwoId,
Name = "Group two",
IsActive = true,
Tags = new List <Tag>()
{
allTags.FirstOrDefault(t => t.Name == "Sport")
}
};
var areaOneId = Guid.NewGuid();
var areaOne = new Area()
{
Id = areaOneId,
Latitude = 10,
Longitude = 10,
Groups = new List <Group>()
{
groupOne, groupTwo
},
IsActive = true,
Radius = RadiusRangeEnum.FiftyMeters
};
groupOne.Areas = new List <Area>()
{
areaOne
};
groupTwo.Areas = new List <Area>()
{
areaOne
};
// ================= Area1 (GR1, GR2) ========
// ================= Area1 (GR3, GR4, GR5) ========
var groupThreeId = Guid.NewGuid();
var groupThree = new Group()
{
Id = groupThreeId,
Name = "Group three",
IsActive = true,
Tags = new List <Tag>()
{
allTags.FirstOrDefault(t => t.Name == "Help"),
allTags.FirstOrDefault(t => t.Name == "Sport")
}
};
var groupFourId = Guid.NewGuid();
var groupFour = new Group()
{
Id = groupFourId,
Name = "Group four",
IsActive = true,
Tags = new List <Tag>()
{
allTags.FirstOrDefault(t => t.Name == "University")
}
};
var groupFiveId = Guid.NewGuid();
var groupFive = new Group()
{
Id = groupFiveId,
Name = "Group five",
IsActive = true,
Tags = new List <Tag>()
{
allTags.FirstOrDefault(t => t.Name == "Help"),
allTags.FirstOrDefault(t => t.Name == "Animals")
}
};
var areaTwoId = Guid.NewGuid();
var areaTwo = new Area()
{
Id = areaTwoId,
Latitude = 20,
Longitude = 20,
Groups = new List <Group>()
{
groupThree, groupFour, groupFive
},
IsActive = true,
Radius = RadiusRangeEnum.FiftyMeters
};
groupThree.Areas = new List <Area>()
{
areaTwo
};
groupFour.Areas = new List <Area>()
{
areaTwo
};
groupFive.Areas = new List <Area>()
{
areaTwo
};
// ================= Area1 (GR3, GR4, GR5) ========
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo, groupThree, groupFour, groupFive
},
Areas = new FakeDbSet <Area>()
{
areaOne, areaTwo
},
Users = new FakeDbSet <User>()
{
user
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
// act
var groupsDependingOnUserSettingsAroundCoordinates = this._userService.UpdateUserLocation(userId, 10, 10);
// assert
Assert.AreEqual(1, groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Count());
Assert.IsTrue(groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Contains(groupTwoId));
Assert.IsTrue(user.Groups.Contains(groupTwo));
Assert.AreEqual(1, user.Groups.Count());
Assert.IsTrue(user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupTwo.Id));
Assert.AreEqual(1, user.HistoryGroups.Count());
// act
groupsDependingOnUserSettingsAroundCoordinates = this._userService.UpdateUserLocation(userId, 15, 15);
// assert
Assert.IsFalse(groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Any());
Assert.IsFalse(user.Groups.Any());
Assert.AreEqual(1, user.HistoryGroups.Count());
Assert.IsTrue(user.HistoryGroups.Select(hgr => hgr.GroupId).Contains(groupTwoId));
// act
groupsDependingOnUserSettingsAroundCoordinates = this._userService.UpdateUserLocation(userId, 20, 20);
// assert
Assert.AreEqual(2, groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Count());
Assert.AreEqual(2, user.Groups.Count());
Assert.IsTrue(user.Groups.Contains(groupThree) && user.Groups.Contains(groupFive));
Assert.AreEqual(3, user.HistoryGroups.Count());
Assert.IsTrue(user.HistoryGroups.Select(hgr => hgr.GroupThatWasPreviouslySubscribed).Contains(groupTwo) &&
user.HistoryGroups.Select(hgr => hgr.GroupThatWasPreviouslySubscribed).Contains(groupThree) &&
user.HistoryGroups.Select(hgr => hgr.GroupThatWasPreviouslySubscribed).Contains(groupFive));
// act
groupsDependingOnUserSettingsAroundCoordinates = this._userService.UpdateUserLocation(userId, 25, 25);
// assert
Assert.IsFalse(groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Any());
Assert.AreEqual(0, user.Groups.Count());
Assert.AreEqual(3, user.HistoryGroups.Count());
Assert.IsTrue(user.HistoryGroups.Select(hgr => hgr.GroupThatWasPreviouslySubscribed).Contains(groupTwo) &&
user.HistoryGroups.Select(hgr => hgr.GroupThatWasPreviouslySubscribed).Contains(groupThree) &&
user.HistoryGroups.Select(hgr => hgr.GroupThatWasPreviouslySubscribed).Contains(groupFive));
// act
groupsDependingOnUserSettingsAroundCoordinates = this._userService.UpdateUserLocation(userId, 10, 10);
// assert
Assert.AreEqual(1, groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Count());
Assert.AreEqual(1, user.Groups.Count());
Assert.IsTrue(user.Groups.Contains(groupTwo));
var histGroups = user.HistoryGroups.Select(hgr => hgr.GroupThatWasPreviouslySubscribed);
Assert.AreEqual(3, user.HistoryGroups.Count());
Assert.IsTrue(histGroups.Contains(groupTwo) && histGroups.Contains(groupThree) && histGroups.Contains(groupFive));
}
public void HistoryGroups_And_RegularGroups_Are_Correct_When_Updating_Location_With_SubscribeToAllOption_TurnedOn()
{
// arrange
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString(),
AutomaticSubscriptionSettings = new AutomaticSubscriptionSetting()
{
AutomaticallySubscribeToAllGroups = true,
AutomaticallySubscribeToAllGroupsWithTag = false
}
};
// ================= Area1 (GR1, GR3) ========
var groupOneId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId,
Name = "Group one",
IsActive = true
};
var groupThreeId = Guid.NewGuid();
var groupThree = new Group()
{
Id = groupThreeId,
Name = "Group three",
IsActive = true
};
var areaOneId = Guid.NewGuid();
var areaOne = new Area()
{
Id = areaOneId,
Latitude = 10,
Longitude = 10,
Groups = new List <Group>()
{
groupOne, groupThree
},
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true
};
// ================= Area1 (GR1, GR3) ========
// ================= Area2 (GR3) ========
var groupSixId = Guid.NewGuid();
var groupSix = new Group()
{
Id = groupSixId,
Name = "Group six",
IsActive = true
};
var areaTwoId = Guid.NewGuid();
var areaTwo = new Area()
{
Id = areaTwoId,
Latitude = 20,
Longitude = 20,
Groups = new List <Group>()
{
groupSix
},
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true
};
// ================= Area2 (GR3) ========
groupOne.Areas = new List <Area>()
{
areaOne
};
groupThree.Areas = new List <Area>()
{
areaOne
};
groupSix.Areas = new List <Area>()
{
areaTwo
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupThree, groupSix
},
Areas = new FakeDbSet <Area>()
{
areaOne, areaTwo
},
Users = new FakeDbSet <User>()
{
user
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
// act
var groupsDependingOnUserSettingsAroundCoordinates = this._userService.UpdateUserLocation(userId, 10, 10);
// assert
Assert.AreEqual(2, groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Count());
Assert.IsTrue(groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Contains(groupOneId) &&
groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Contains(groupThreeId));
Assert.IsTrue(user.Groups.Contains(groupOne) && user.Groups.Contains(groupThree));
Assert.IsTrue(user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupOne.Id) &&
user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupThree.Id));
// act
groupsDependingOnUserSettingsAroundCoordinates = this._userService.UpdateUserLocation(userId, 15, 15);
// assert
Assert.AreEqual(0, groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Count());
Assert.IsFalse(user.Groups.Contains(groupOne) && user.Groups.Contains(groupThree));
Assert.IsTrue(user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupOne.Id) &&
user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupThree.Id));
// act
groupsDependingOnUserSettingsAroundCoordinates = this._userService.UpdateUserLocation(userId, 20, 20);
// assert
Assert.AreEqual(1, groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Count());
Assert.IsTrue(groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Contains(groupSixId));
Assert.IsTrue(user.Groups.Contains(groupSix));
Assert.IsTrue(user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupOne.Id) &&
user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupThree.Id) &&
user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupSix.Id));
// act
groupsDependingOnUserSettingsAroundCoordinates = this._userService.UpdateUserLocation(userId, 25, 25);
// assert
Assert.AreEqual(0, groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Count());
Assert.IsFalse(user.Groups.Any());
Assert.IsTrue(user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupOne.Id) &&
user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupThree.Id) &&
user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupSix.Id));
// act
groupsDependingOnUserSettingsAroundCoordinates = this._userService.UpdateUserLocation(userId, 10, 10);
// assert
Assert.AreEqual(2, groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Count());
Assert.IsTrue(groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Contains(groupOneId) &&
groupsDependingOnUserSettingsAroundCoordinates.SubscribedGroupIds.Contains(groupThreeId));
Assert.IsTrue(user.Groups.Contains(groupOne) && user.Groups.Contains(groupThree));
Assert.IsTrue(user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupOne.Id) &&
user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupThree.Id) &&
user.HistoryGroups.Select(gr => gr.GroupId).Contains(groupSix.Id));
}
public void When_User_Location_Is_Updated_Proper_ResponseDto_IsReturned()
{
// arrange
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString(),
AutomaticSubscriptionSettings = new AutomaticSubscriptionSetting()
{
AutomaticallySubscribeToAllGroups = true,
AutomaticallySubscribeToAllGroupsWithTag = false
}
};
var groupOneId = Guid.NewGuid();
var groupTwoId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId, Name = "GroupOne", IsActive = true, Users = new List <User>()
};
var groupTwo = new Group()
{
Id = groupTwoId, Name = "GroupTwo", IsActive = true, Users = new List <User>()
};
var areaId = Guid.NewGuid();
var area = new Area()
{
Id = areaId,
Latitude = 10.00000,
Longitude = 10.00000,
Groups = new List <Group>()
{
groupOne, groupTwo
},
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true
};
groupOne.Areas = new List <Area>()
{
area
};
groupTwo.Areas = new List <Area>()
{
area
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo
},
Areas = new FakeDbSet <Area>()
{
area
},
Users = new FakeDbSet <User>()
{
user
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
// act
var relateUserToGroupsDto = new RelateUserToGroupsDto()
{
UserId = userId,
Latitude = 10,
Longitude = 10,
GroupsUserSubscribes = new List <Guid>()
{
groupOneId, groupTwoId
}
};
this._subscriptionService.RelateUserToGroups(relateUserToGroupsDto);
Assert.IsNotNull(user.Groups);
Assert.IsNotNull(user.HistoryGroups);
Assert.AreEqual(2, user.Groups.Count);
Assert.AreEqual(2, user.HistoryGroups.Count);
this._userService.UpdateUserLocation(userId, 20, 20);
Assert.AreEqual(0, user.Groups.Count);
Assert.AreEqual(2, user.HistoryGroups.Count);
var updateResponse = this._userService.UpdateUserLocation(userId, 10.00009, 10.00009);
// TODO: When implemented double SecondsToClosestBoundary(double latitude, double longitude); update the assertions here
Assert.AreEqual(2, updateResponse.SubscribedGroupIds.Count());
}
public void We_Can_Get_Groups_Around_Coordinates_Based_On_Subscription_Settings_SubscribeAllAvailableOptionSet()
{
// arrange
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
AutomaticSubscriptionSettings = new AutomaticSubscriptionSetting()
{
AutomaticallySubscribeToAllGroups = true,
AutomaticallySubscribeToAllGroupsWithTag = false
}
};
// ================= Area1 (GR1, GR2) ========
var groupOneId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId, Name = "Group one", IsActive = true
};
var groupTwoId = Guid.NewGuid();
var groupTwo = new Group()
{
Id = groupTwoId, Name = "Group two", IsActive = true
};
var areaOneId = Guid.NewGuid();
var areaOne = new Area()
{
Id = areaOneId, Latitude = 10, Longitude = 10, Groups = new List <Group>()
{
groupOne, groupTwo
},
Radius = RadiusRangeEnum.FiftyMeters, IsActive = true
};
// ================= Area1 (GR1, GR2) ========
// ================= Area2 (GR3) ========
var groupThreeId = Guid.NewGuid();
var groupThree = new Group()
{
Id = groupThreeId, Name = "Group three", IsActive = true
};
var areaTwoId = Guid.NewGuid();
var areaTwo = new Area()
{
Id = areaTwoId, Latitude = 20, Longitude = 20, Groups = new List <Group>()
{
groupThree
},
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo, groupThree
},
Areas = new FakeDbSet <Area>()
{
areaOne, areaTwo
},
Users = new FakeDbSet <User>()
{
user
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
// act
var groupsDependingOnUserSettingsAroundCoordinates =
this._subscriptionSettingsService.GroupsForUserAroundCoordinatesBasedOnUserSettings(userId, 10, 10);
// assert
Assert.AreEqual(2, groupsDependingOnUserSettingsAroundCoordinates.Count());
// act
groupsDependingOnUserSettingsAroundCoordinates =
this._subscriptionSettingsService.GroupsForUserAroundCoordinatesBasedOnUserSettings(userId, 15, 15);
// assert
Assert.AreEqual(0, groupsDependingOnUserSettingsAroundCoordinates.Count());
// act
groupsDependingOnUserSettingsAroundCoordinates =
this._subscriptionSettingsService.GroupsForUserAroundCoordinatesBasedOnUserSettings(userId, 20, 20);
// assert
Assert.AreEqual(1, groupsDependingOnUserSettingsAroundCoordinates.Count());
// act
groupsDependingOnUserSettingsAroundCoordinates =
this._subscriptionSettingsService.GroupsForUserAroundCoordinatesBasedOnUserSettings(userId, 25, 25);
// assert
Assert.AreEqual(0, groupsDependingOnUserSettingsAroundCoordinates.Count());
}
public void We_Can_Get_AreaMetadata()
{
// arrange
var myLocationLatitude = 10;
var myLocationLongitude = 10;
var groupOneId = Guid.NewGuid();
var groupTwoId = Guid.NewGuid();
var workingTag = new Tag()
{
Id = Guid.Parse("caf77dee-a94f-49cb-b51f-e0c0e1067541"),
Name = "Help"
};
var groupOne = new Group()
{
Id = groupOneId,
Name = "GroupOne",
Users = new List <User>(),
Tags = new List <Tag>()
{
workingTag
}
};
var groupTwo = new Group()
{
Id = groupTwoId, Name = "GroupTwo", Users = new List <User>(), Tags = new List <Tag>()
{
workingTag
}
};
var areaId = Guid.NewGuid();
var area = new Area()
{
Id = areaId,
Latitude = 10,
Longitude = 10,
Groups = new List <Group>()
{
groupOne, groupTwo
}
};
groupOne.Areas = new List <Area>()
{
area
};
groupTwo.Areas = new List <Area>()
{
area
};
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo
},
Areas = new FakeDbSet <Area>()
{
area
},
Users = new FakeDbSet <User>()
{
user
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
// act
var areaMetadata = this._areaService.GetMetadataForArea(myLocationLatitude, myLocationLongitude, areaId);
// assert
Assert.IsNotNull(areaMetadata);
Assert.AreEqual(areaMetadata.TagIds.Count(), 1);
Assert.AreEqual(areaMetadata.DistanceTo, 0);
}
public void We_Can_Get_Metadata_For_Multiple_Areas()
{
// arrange
var myLocationLatitude = 10;
var myLocationLongitude = 10;
var groupOneId = Guid.NewGuid();
var groupTwoId = Guid.NewGuid();
var workingTag = new Tag()
{
Id = Guid.Parse("caf77dee-a94f-49cb-b51f-e0c0e1067541"),
Name = "Help"
};
var groupOne = new Group()
{
Id = groupOneId,
Name = "GroupOne",
Users = new List <User>(),
Tags = new List <Tag>()
{
workingTag
}
};
var groupTwo = new Group()
{
Id = groupTwoId, Name = "GroupTwo", Users = new List <User>(), Tags = new List <Tag>()
{
workingTag
}
};
var firstAreaId = Guid.NewGuid();
var firstArea = new Area()
{
Id = firstAreaId,
Latitude = 10,
Longitude = 10,
Groups = new List <Group>()
{
groupOne, groupTwo
},
Radius = RadiusRangeEnum.FiftyMeters
};
var secondAreaId = Guid.NewGuid();
var secondArea = new Area()
{
Id = firstAreaId,
Latitude = 10.00001,
Longitude = 10.00001,
Groups = new List <Group>()
{
groupOne, groupTwo
},
Radius = RadiusRangeEnum.FiveHundredMeters
};
groupOne.Areas = new List <Area>()
{
firstArea, secondArea
};
groupTwo.Areas = new List <Area>()
{
firstArea, secondArea
};
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo
},
Areas = new FakeDbSet <Area>()
{
firstArea, secondArea
},
Users = new FakeDbSet <User>()
{
user
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
// act
var multipleAreasMetadataRequestDto = new MultipleAreasMetadataRequestDto()
{
AreaIds = new List <Guid>()
{
firstAreaId, secondAreaId
},
Latitude = myLocationLatitude,
Longitude = myLocationLongitude
};
var multipleAreasMetadata = this._areaService.GetMultipleAreasMetadata(multipleAreasMetadataRequestDto);
// assert
Assert.IsNotNull(multipleAreasMetadata);
Assert.AreEqual(multipleAreasMetadata.Count(), 2);
Assert.IsTrue(multipleAreasMetadata.Any(a => a.DistanceTo == 0));
}
public void We_Can_Relate_User_To_Groups()
{
// arrange
var groupOneId = Guid.NewGuid();
var groupTwoId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId, Name = "GroupOne", Users = new List <User>(), IsActive = true
};
var groupTwo = new Group()
{
Id = groupTwoId, Name = "GroupTwo", Users = new List <User>(), IsActive = true
};
var area = new Area()
{
Id = Guid.NewGuid(),
Latitude = 10,
Longitude = 10,
Groups = new List <Group>()
{
groupOne, groupTwo
},
IsActive = true
};
groupOne.Areas = new List <Area>()
{
area
};
groupTwo.Areas = new List <Area>()
{
area
};
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var firstHistoryGroup = new HistoryGroup()
{
DateTimeGroupWasSubscribed = DateTime.UtcNow,
GroupId = groupOneId,
GroupThatWasPreviouslySubscribed = groupOne,
UserId = userId,
UserWhoSubscribedGroup = user,
Id = Guid.NewGuid()
};
var secondHistoryGroup = new HistoryGroup()
{
DateTimeGroupWasSubscribed = DateTime.UtcNow,
GroupId = groupTwoId,
GroupThatWasPreviouslySubscribed = groupTwo,
UserId = userId,
UserWhoSubscribedGroup = user,
Id = Guid.NewGuid()
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo
},
Areas = new FakeDbSet <Area>()
{
area
},
Users = new FakeDbSet <User>()
{
user
},
HistoryGroups = new FakeDbSet <HistoryGroup>()
{
firstHistoryGroup, secondHistoryGroup
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.HistoryGroupRepository).Returns(new HistoryGroupRepository(populatedDatabase));
var relateUserToGroupsRequest = new RelateUserToGroupsDto()
{
UserId = userId,
Latitude = 10,
Longitude = 10,
GroupsUserSubscribes = new List <Guid>()
{
groupOneId, groupTwoId
}
};
// act
this._subscriptionService.RelateUserToGroups(relateUserToGroupsRequest);
var userSubscribtionsAroundCoordintes = this._groupService.GetUserSubscriptions(userId, 10, 10);
// assert subscription works
Assert.IsNotNull(userSubscribtionsAroundCoordintes);
Assert.AreEqual(userSubscribtionsAroundCoordintes.Count(), 2);
Assert.IsTrue(userSubscribtionsAroundCoordintes.Contains(groupOneId));
Assert.IsTrue(userSubscribtionsAroundCoordintes.Contains(groupTwoId));
Assert.IsNotNull(user.HistoryGroups);
Assert.AreEqual(user.HistoryGroups.Count(), 2);
var historyGroupIds = user.HistoryGroups.Select(hgr => hgr.GroupId).ToList();
Assert.IsTrue(historyGroupIds.Contains(groupOneId) && historyGroupIds.Contains(groupTwoId));
// arrange
relateUserToGroupsRequest = new RelateUserToGroupsDto()
{
UserId = userId,
Latitude = 10,
Longitude = 10,
GroupsUserSubscribes = new List <Guid>()
{
groupTwoId
}
};
groupOne.Users = new List <User>()
{
user
};
groupTwo.Users = new List <User>()
{
user
};
user.HistoryGroups = new List <HistoryGroup>()
{
firstHistoryGroup, secondHistoryGroup
};
// act
this._subscriptionService.RelateUserToGroups(relateUserToGroupsRequest);
userSubscribtionsAroundCoordintes = this._groupService.GetUserSubscriptions(userId, 10, 10);
// assert unsubscription works
Assert.IsNotNull(userSubscribtionsAroundCoordintes);
Assert.AreEqual(userSubscribtionsAroundCoordintes.Count(), 1);
Assert.IsFalse(userSubscribtionsAroundCoordintes.Contains(groupOneId));
Assert.IsTrue(userSubscribtionsAroundCoordintes.Contains(groupTwoId));
Assert.IsTrue(user.HistoryGroups != null);
Assert.IsTrue(user.HistoryGroups.Select(hgr => hgr.GroupId).Contains(groupTwoId));
Assert.IsTrue(this._mockedLikkleUoW.Object.HistoryGroupRepository.AllHistoryGroups().Count() == 2);
// arrange
var groupThree = new Group()
{
Id = Guid.NewGuid(), Name = "GroupThree", Users = new List <User>(), IsActive = true
};
var groupFour = new Group()
{
Id = Guid.NewGuid(), Name = "GroupFour", Users = new List <User>(), IsActive = true
};
groupThree.Areas = new List <Area>()
{
area
};
groupFour.Areas = new List <Area>()
{
area
};
area.Groups.Clear();
area.Groups.Add(groupThree);
area.Groups.Add(groupFour);
populatedDatabase.Groups = new FakeDbSet <Group>()
{
groupThree, groupFour
};
relateUserToGroupsRequest = new RelateUserToGroupsDto()
{
UserId = userId,
Latitude = 10,
Longitude = 10,
GroupsUserSubscribes = new List <Guid>()
{
groupThree.Id, groupFour.Id
}
};
// act
this._subscriptionService.RelateUserToGroups(relateUserToGroupsRequest);
userSubscribtionsAroundCoordintes = this._groupService.GetUserSubscriptions(userId, 10, 10);
// assert
Assert.IsNotNull(userSubscribtionsAroundCoordintes);
Assert.AreEqual(userSubscribtionsAroundCoordintes.Count(), 2);
Assert.IsFalse(userSubscribtionsAroundCoordintes.Contains(groupOneId));
Assert.IsFalse(userSubscribtionsAroundCoordintes.Contains(groupTwoId));
Assert.IsTrue(userSubscribtionsAroundCoordintes.Contains(groupThree.Id));
Assert.IsTrue(userSubscribtionsAroundCoordintes.Contains(groupFour.Id));
}
public void We_Can_Insert_New_User()
{
// arrange
var firstLanguageId = Guid.Parse("e9260fb3-5183-4c3e-9bd2-c606d03b7bcb");
var secondLanguageId = Guid.Parse("05872235-365b-41f8-ab50-3913ffe9c601");
var newUserStsId = "https://boongaloocompanysts/identity3025f46b-3070-4f75-809d-44b7ae5b8e6a";
var groupOneId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId, Name = "GroupOne", Users = new List <User>()
};
var area = new Area()
{
Id = Guid.NewGuid(),
Latitude = 10,
Longitude = 10,
Groups = new List <Group>()
{
groupOne
}
};
groupOne.Areas = new List <Area>()
{
area
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne
},
Areas = new FakeDbSet <Area>()
{
area
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
var newUserRequestDto = new NewUserRequestDto()
{
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = newUserStsId,
LanguageIds = new List <Guid>()
{
firstLanguageId, secondLanguageId
},
GroupIds = new List <Guid>()
{
groupOneId
},
BirthDate = DateTime.Parse(this.InitialDateString)
};
// act
var userId = this._userService.InsertNewUser(newUserRequestDto);
// assert
Assert.IsNotNull(userId);
var user = this._userService.GetUserById(userId);
Assert.IsNotNull(user);
Assert.IsNotNull(user.Id);
Assert.AreEqual(userId, user.Id);
Assert.AreEqual(user.Languages.Count(), 2);
Assert.AreEqual(user.BirthDate, DateTime.Parse(this.InitialDateString));
}
public void Area_Gets_Inactive_When_No_Active_Groups_Belong_To_It()
{
// arrange
this._configurationWrapperMock.Setup(config => config.AutomaticallyCleanupGroupsAndAreas).Returns(true);
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var groupOneId = Guid.NewGuid();
var groupTwoId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId, Name = "GroupOne", Users = new List <User>()
{
user
}, IsActive = true
};
var groupTwo = new Group()
{
Id = groupTwoId, Name = "GroupTwo", Users = new List <User>(), IsActive = false
};
var areaId = Guid.NewGuid();
var area = new Area()
{
Id = areaId,
Latitude = 10,
Longitude = 10,
Groups = new List <Group>()
{
groupOne, groupTwo
},
IsActive = true
};
groupOne.Areas = new List <Area>()
{
area
};
groupTwo.Areas = new List <Area>()
{
area
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo
},
Users = new FakeDbSet <User>()
{
user
},
Areas = new FakeDbSet <Area>()
{
area
}
}
.Seed();
DataGenerator.SetupAreaUserAndGroupRepositories(this._mockedLikkleUoW, populatedDatabase);
// act
var relateUserToGroupsRequest = new RelateUserToGroupsDto()
{
UserId = userId,
Latitude = 10,
Longitude = 10,
GroupsUserSubscribes = new List <Guid>()
{
groupTwoId
}
};
this._subscriptionService.RelateUserToGroups(relateUserToGroupsRequest);
// assert
Assert.AreEqual(2, this._areaService.GetAreaById(areaId).Groups.Count());
Assert.IsFalse(this._mockedLikkleUoW.Object.GroupRepository.GetGroupById(groupOneId).IsActive);
Assert.IsFalse(this._mockedLikkleUoW.Object.GroupRepository.GetGroupById(groupTwoId).IsActive);
Assert.IsFalse(this._mockedLikkleUoW.Object.AreaRepository.GetAreaById(areaId).IsActive);
}
public void When_User_Location_Is_Changed_Group_Is_Removed_But_HistoryGroup_Stays()
{
// arrange
var groupOneId = Guid.NewGuid();
var groupTwoId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId, Name = "GroupOne", Users = new List <User>()
};
var groupTwo = new Group()
{
Id = groupTwoId, Name = "GroupTwo", Users = new List <User>()
};
var area = new Area()
{
Id = Guid.NewGuid(),
Latitude = 10,
Longitude = 10,
Groups = new List <Group>()
{
groupOne, groupTwo
}
};
groupOne.Areas = new List <Area>()
{
area
};
groupTwo.Areas = new List <Area>()
{
area
};
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo
},
Areas = new FakeDbSet <Area>()
{
area
},
Users = new FakeDbSet <User>()
{
user
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
var relateUserToGroupsRequest = new RelateUserToGroupsDto()
{
UserId = userId,
Latitude = 10,
Longitude = 10,
GroupsUserSubscribes = new List <Guid>()
{
groupOneId, groupTwoId
}
};
// act
this._subscriptionService.RelateUserToGroups(relateUserToGroupsRequest);
Assert.IsNotNull(user.Groups);
Assert.AreEqual(user.Groups.Count(), 2);
Assert.IsNotNull(user.HistoryGroups);
Assert.AreEqual(user.HistoryGroups.Count(), 2);
this._userService.UpdateUserLocation(userId, 90, 90);
Assert.AreEqual(user.Groups.Count(), 0);
Assert.AreEqual(user.HistoryGroups.Count(), 2);
}
public void We_Can_Activate_Previously_Not_Active_Group()
{
// arrange
var userId = Guid.NewGuid();
var dbUser = new User()
{
Id = userId,
Groups = new List <Group>()
};
var groupOneId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId,
IsActive = true
};
var newAreaId = Guid.NewGuid();
var newArea = new Area()
{
Id = newAreaId,
Latitude = 10,
Longitude = 10,
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = false,
Groups = new List <Group>()
{
groupOne
}
};
var secondNewAreaId = Guid.NewGuid();
var secondNewArea = new Area()
{
Id = secondNewAreaId,
Latitude = 10,
Longitude = 10,
Radius = RadiusRangeEnum.FiveHundredMeters,
IsActive = false,
Groups = new List <Group>()
{
groupOne
}
};
groupOne.Areas = new List <Area>()
{
newArea, secondNewArea
};
var populatedDatabase = new FakeLikkleDbContext()
{
Areas = new FakeDbSet <Area>()
{
newArea, secondNewArea
},
Groups = new FakeDbSet <Group>()
{
groupOne
},
Users = new FakeDbSet <User>()
{
dbUser
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
// act
this._groupService.ActivateGroup(groupOneId, userId);
// assert
Assert.IsTrue(groupOne.IsActive);
Assert.IsTrue(newArea.IsActive);
Assert.IsTrue(secondNewArea.IsActive);
Assert.IsTrue(dbUser.Groups.Any());
Assert.IsTrue(dbUser.Groups.Any(gr => gr.Id == groupOneId));
}
public void We_Can_Get_Users_From_Area()
{
// arrange
var firstUserId = Guid.NewGuid();
var firstUser = new User()
{
Id = firstUserId,
FirstName = "Stefcho",
LastName = "Stefchev",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var secondUserId = Guid.NewGuid();
var secondUser = new User()
{
Id = secondUserId,
FirstName = "Other",
LastName = "Name",
Email = "*****@*****.**",
IdsrvUniqueId = Guid.NewGuid().ToString()
};
var groupOneId = Guid.NewGuid();
var groupTwoId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId, Name = "GroupOne", Users = new List <User>()
{
firstUser
}
};
var groupTwo = new Group()
{
Id = groupTwoId, Name = "GroupTwo", Users = new List <User>()
{
firstUser, secondUser
}
};
var areaId = Guid.NewGuid();
var area = new Area()
{
Id = areaId,
Latitude = 10,
Longitude = 10,
Groups = new List <Group>()
{
groupOne, groupTwo
}
};
groupOne.Areas = new List <Area>()
{
area
};
groupTwo.Areas = new List <Area>()
{
area
};
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo
},
Areas = new FakeDbSet <Area>()
{
area
},
Users = new FakeDbSet <User>()
{
firstUser, secondUser
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
// act
var usersFromArea = this._areaService.GetUsersFromArea(areaId);
// assert
Assert.IsNotNull(usersFromArea);
var userIds = usersFromArea.Select(u => u.Id);
Assert.IsTrue(userIds.Count() == userIds.Distinct().Count());
Assert.AreEqual(userIds.Count(), 2);
}
public void We_Can_Get_List_Of_Previously_Created_Groups_When_At_A_Place_With_Previous_Activity()
{
// arrange
var userId = Guid.NewGuid();
var dbUser = new User()
{
Id = userId,
AutomaticSubscriptionSettings = null
};
var groupOneId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId,
Name = "Group one",
IsActive = false
};
var groupTwoId = Guid.NewGuid();
var groupTwo = new Group()
{
Id = groupTwoId,
Name = "Group two",
IsActive = true
};
var groupThreeId = Guid.NewGuid();
var groupThree = new Group()
{
Id = groupThreeId,
Name = "Group three",
IsActive = false
};
dbUser.HistoryGroups = new List <HistoryGroup>()
{
new HistoryGroup()
{
DateTimeGroupWasSubscribed = DateTime.UtcNow.AddDays(-2),
GroupId = groupOneId,
GroupThatWasPreviouslySubscribed = groupOne,
Id = Guid.NewGuid(),
UserId = userId,
UserWhoSubscribedGroup = dbUser
},
new HistoryGroup()
{
DateTimeGroupWasSubscribed = DateTime.UtcNow.AddDays(-2),
GroupId = groupThreeId,
GroupThatWasPreviouslySubscribed = groupThree,
Id = Guid.NewGuid(),
UserId = userId,
UserWhoSubscribedGroup = dbUser
}
};
groupOne.Users = new List <User>()
{
dbUser
};
groupTwo.Users = new List <User>()
{
dbUser
};
groupThree.Users = new List <User>()
{
dbUser
};
var areaOneId = Guid.NewGuid();
var areaOne = new Area()
{
Id = areaOneId,
Latitude = 10.0000000,
Longitude = 10.0000000,
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true,
Groups = new List <Group>()
{
groupOne, groupTwo
}
};
var areaTwoId = Guid.NewGuid();
var areaTwo = new Area()
{
Id = areaTwoId,
Latitude = 10.0000001,
Longitude = 10.0000001,
Radius = RadiusRangeEnum.HunderdAndFiftyMeters,
IsActive = true,
Groups = new List <Group>()
{
groupOne, groupTwo, groupThree
}
};
groupOne.Areas = new List <Area>()
{
areaOne, areaTwo
};
groupTwo.Areas = new List <Area>()
{
areaOne, areaTwo
};
groupThree.Areas = new List <Area>()
{
areaTwo
};
var populatedDatabase = new FakeLikkleDbContext()
{
Users = new FakeDbSet <User>()
{
dbUser
},
Areas = new FakeDbSet <Area>()
{
areaOne, areaTwo
},
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo, groupThree
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.TagRepository).Returns(new TagRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
// act
var result = this._groupService.GetGroupCreationType(10, 10, userId);
// assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.PrevousGroupsList);
Assert.AreEqual(result.CreationType, CreateGroupActionTypeEnum.ListOfPreviouslyCreatedOrSubscribedGroups);
Assert.AreEqual(2, result.PrevousGroupsList.Count());
}
public void We_Get_Choice_Screen_When_Creating_A_group_In_Existing_Active_Area()
{
// arrange
var userId = Guid.NewGuid();
var dbUser = new User()
{
Id = userId,
AutomaticSubscriptionSettings = null
};
var groupOneId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId,
IsActive = true
};
var groupTwoId = Guid.NewGuid();
var groupTwo = new Group()
{
Id = groupTwoId,
IsActive = true
};
var newAreaId = Guid.NewGuid();
var newArea = new Area()
{
Id = newAreaId,
Latitude = 10,
Longitude = 10,
Radius = RadiusRangeEnum.FiftyMeters,
IsActive = true,
Groups = new List <Group>()
{
groupOne, groupTwo
}
};
groupOne.Areas = new List <Area>()
{
newArea
};
groupTwo.Areas = new List <Area>()
{
newArea
};
var populatedDatabase = new FakeLikkleDbContext()
{
Users = new FakeDbSet <User>()
{
dbUser
},
Areas = new FakeDbSet <Area>()
{
newArea
},
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.TagRepository).Returns(new TagRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
// act
var result = this._groupService.GetGroupCreationType(10, 10, userId);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(result.CreationType, CreateGroupActionTypeEnum.ChoiceScreen);
}
public void We_Can_Get_Groups_Around_Coordinates_Based_On_Subscription_Settings_SubscribeAllWithTagOptionSet()
{
var allTags = this._mockedLikkleUoW.Object.TagRepository.GetAllTags().ToList();
// arrange
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
AutomaticSubscriptionSettings = new AutomaticSubscriptionSetting()
{
AutomaticallySubscribeToAllGroups = false,
AutomaticallySubscribeToAllGroupsWithTag = true,
Tags = allTags.Where(t => t.Name == "Sport" || t.Name == "Help").ToList()
}
};
// ================= Area1 (GR1, GR2) ========
var groupOneId = Guid.NewGuid();
var groupOne = new Group()
{
Id = groupOneId,
Name = "Group one",
IsActive = true,
Tags = new List <Tag>()
{
allTags.FirstOrDefault(t => t.Name == "Animals")
}
};
var groupTwoId = Guid.NewGuid();
var groupTwo = new Group()
{
Id = groupTwoId,
Name = "Group two",
IsActive = true,
Tags = new List <Tag>()
{
allTags.FirstOrDefault(t => t.Name == "Sport")
}
};
var areaOneId = Guid.NewGuid();
var areaOne = new Area()
{
Id = areaOneId,
Latitude = 10,
Longitude = 10,
Groups = new List <Group>()
{
groupOne, groupTwo
}, IsActive = true, Radius = RadiusRangeEnum.FiftyMeters
};
// ================= Area1 (GR1, GR2) ========
// ================= Area1 (GR3, GR4, GR5) ========
var groupThreeId = Guid.NewGuid();
var groupThree = new Group()
{
Id = groupThreeId,
Name = "Group three",
IsActive = true,
Tags = new List <Tag>()
{
allTags.FirstOrDefault(t => t.Name == "Help"),
allTags.FirstOrDefault(t => t.Name == "Sport")
}
};
var groupFourId = Guid.NewGuid();
var groupFour = new Group()
{
Id = groupFourId,
Name = "Group four",
IsActive = true,
Tags = new List <Tag>()
{
allTags.FirstOrDefault(t => t.Name == "University")
}
};
var groupFiveId = Guid.NewGuid();
var groupFive = new Group()
{
Id = groupFiveId,
Name = "Group five",
IsActive = true,
Tags = new List <Tag>()
{
allTags.FirstOrDefault(t => t.Name == "Help"),
allTags.FirstOrDefault(t => t.Name == "Animals")
}
};
var areaTwoId = Guid.NewGuid();
var areaTwo = new Area()
{
Id = areaTwoId,
Latitude = 20,
Longitude = 20,
Groups = new List <Group>()
{
groupThree, groupFour, groupFive
}, IsActive = true, Radius = RadiusRangeEnum.FiftyMeters
};
// ================= Area1 (GR3, GR4, GR5) ========
var populatedDatabase = new FakeLikkleDbContext()
{
Groups = new FakeDbSet <Group>()
{
groupOne, groupTwo, groupThree, groupFour, groupFive
},
Areas = new FakeDbSet <Area>()
{
areaOne, areaTwo
},
Users = new FakeDbSet <User>()
{
user
}
}
.Seed();
this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));
this._mockedLikkleUoW.Setup(uow => uow.UserRepository).Returns(new UserRepository(populatedDatabase));
// act
var groupsDependingOnUserSettingsAroundCoordinates =
this._subscriptionSettingsService.GroupsForUserAroundCoordinatesBasedOnUserSettings(userId, 10, 10);
// assert
Assert.AreEqual(1, groupsDependingOnUserSettingsAroundCoordinates.Count());
Assert.IsTrue(groupsDependingOnUserSettingsAroundCoordinates.FirstOrDefault() == groupTwoId);
// act
groupsDependingOnUserSettingsAroundCoordinates =
this._subscriptionSettingsService.GroupsForUserAroundCoordinatesBasedOnUserSettings(userId, 15, 15);
// assert
Assert.AreEqual(0, groupsDependingOnUserSettingsAroundCoordinates.Count());
// act
groupsDependingOnUserSettingsAroundCoordinates =
this._subscriptionSettingsService.GroupsForUserAroundCoordinatesBasedOnUserSettings(userId, 20, 20);
// assert
Assert.AreEqual(2, groupsDependingOnUserSettingsAroundCoordinates.Count());
var observedGroups =
this._mockedLikkleUoW.Object.GroupRepository.GetGroups()
.Where(gr => groupsDependingOnUserSettingsAroundCoordinates.Contains(gr.Id));
Assert.IsTrue(observedGroups.Any(gr => gr.Tags.Any(igr => igr.Name == "Sport")) && observedGroups.Any(gr => gr.Tags.Any(igr => igr.Name == "Help")));
}
