public void TestFindNotesByRegion()
{
INoteAccessor accessor = this._provider.GetService <INoteAccessor>();
IUserAccessor userAccessor = this._provider.GetService <IUserAccessor>();
var ian = userAccessor.FindUser("ian");
var zach = userAccessor.FindUser("zach");
Assert.Equal(3, accessor.FindNotes(_campus, ian).Count);
Assert.Equal(0, accessor.FindNotes(_bottoms, ian).Count);
Assert.Equal(5, accessor.FindNotes(_lincoln, ian).Count);
Assert.Equal(0, accessor.FindNotes(_south, ian).Count);
Assert.Equal(0, accessor.FindNotes(_campus, zach).Count);
Assert.Equal(2, accessor.FindNotes(_bottoms, zach).Count);
Assert.Equal(2, accessor.FindNotes(_lincoln, zach).Count);
Assert.Equal(0, accessor.FindNotes(_south, zach).Count);
Assert.Throws <ArgumentException>(() =>
{
accessor.FindNotes(null, ian);
});
Assert.Throws <ArgumentException>(() =>
{
accessor.FindNotes(_campus, null);
});
Assert.Throws <ArgumentException>(() =>
{
accessor.FindNotes(null, null);
});
}
public void TestFindNotesByUser()
{
INoteAccessor accessor = this._provider.GetService <INoteAccessor>();
IUserAccessor userAccessor = this._provider.GetService <IUserAccessor>();
var ian = userAccessor.FindUser("ian");
var ianNotes = accessor.FindNotes(ian);
var zach = userAccessor.FindUser("zach");
var zachNotes = accessor.FindNotes(zach);
Assert.Equal(5, ianNotes.Count);
Assert.Equal(2, zachNotes.Count);
Assert.Throws <ArgumentException>(() => { accessor.FindNotes((Contracts.DTO.User)null); });
}
public void TestAddUser()
{
IUserAccessor accessor = this._provider.GetService <IUserAccessor>();
IUnitOfWork uow = this._provider.GetService <IUnitOfWork>();
PersistenceContext context = this._provider.GetService <PersistenceContext>();
Assert.Equal(3, context.Users.Count());
var user = new Contracts.DTO.User()
{
AvatarUrl = @"http://www.google.com",
Email = "*****@*****.**",
FirstName = "Test",
LastName = "User",
Location = "Any Place, USA"
};
user = accessor.AddUser(user);
uow.Commit();
Assert.Equal(4, context.Users.Count());
var users = context.Users.ToList();
Assert.Equal("Any Place, USA", context.Users.Where(u => u.UserId == user.UserId)
.FirstOrDefault().Location);
Assert.Equal(user, accessor.FindUser(user.UserId));
/* Test some bad data */
Assert.Throws <ArgumentException>(() =>
{
accessor.AddUser(null);
});
Assert.Throws <ArgumentException>(() =>
{
accessor.AddUser(new Contracts.DTO.User()
{
FirstName = "Bad",
LastName = "User"
});
});
/* Test entry of a user with an already existing ID */
Assert.Throws <ArgumentException>(() =>
{
accessor.AddUser(new Contracts.DTO.User()
{
FirstName = "Bad",
LastName = "User",
Location = "Death Valley",
Email = "*****@*****.**",
UserId = "bill"
});
});
}
public void TestFindPinsByBox()
{
INoteAccessor accessor = this._provider.GetService <INoteAccessor>();
IUserAccessor userAccessor = this._provider.GetService <IUserAccessor>();
var ian = userAccessor.FindUser("ian");
var zach = userAccessor.FindUser("zach");
var kauf = accessor.FindPin("kauf");
var destinations = accessor.FindPin("dest");
var fuse = accessor.FindPin("fuse");
Assert.Equal(1, accessor.FindPins(_campus, ian).Count);
Assert.Equal(0, accessor.FindPins(_bottoms, ian).Count);
Assert.Equal(2, accessor.FindPins(_lincoln, ian).Count);
Assert.Equal(0, accessor.FindPins(_south, ian).Count);
Assert.Equal(0, accessor.FindPins(_campus, zach).Count);
Assert.Equal(1, accessor.FindPins(_bottoms, zach).Count);
Assert.Equal(1, accessor.FindPins(_lincoln, zach).Count);
Assert.Equal(0, accessor.FindPins(_south, zach).Count);
var ianPins = accessor.FindPins(_lincoln, ian);
Assert.True(ianPins.Contains(kauf));
Assert.True(ianPins.Contains(fuse));
Assert.Throws <ArgumentException>(() =>
{
accessor.FindPins(null, ian);
});
Assert.Throws <ArgumentException>(() =>
{
accessor.FindPins(_campus, null);
});
Assert.Throws <ArgumentException>(() =>
{
accessor.FindPins(null, null);
});
}
public void TestFindUser()
{
IUserAccessor accessor = this._provider.GetService <IUserAccessor>();
var ian = accessor.FindUser("ian");
var bill = accessor.FindUser("bill");
Assert.NotEqual(ian, bill);
Assert.Equal("Ian", ian.FirstName);
Assert.Equal("Cottingham", ian.LastName);
Assert.Equal("Seattle, WA", bill.Location);
Assert.Equal("Lincoln, NE", ian.Location);
Assert.Equal("Gates", bill.LastName);
var otherian = accessor.FindUserByEmail("*****@*****.**");
Assert.NotNull(otherian);
Assert.Equal(ian, otherian);
Assert.NotEqual(bill, otherian);
}
public void TestFindPinsByUser()
{
INoteAccessor accessor = this._provider.GetService <INoteAccessor>();
IUserAccessor userAccessor = this._provider.GetService <IUserAccessor>();
var ian = userAccessor.FindUser("ian");
var zach = userAccessor.FindUser("zach");
var kauf = accessor.FindPin("kauf");
var destinations = accessor.FindPin("dest");
var fuse = accessor.FindPin("fuse");
var ianPins = accessor.FindPins(ian);
var zachPins = accessor.FindPins(zach);
Assert.Equal(2, ianPins.Count);
Assert.True(ianPins.Contains(kauf));
Assert.True(ianPins.Contains(fuse));
Assert.True(zachPins.Contains(destinations));
Assert.Throws <ArgumentException>(() => { accessor.FindPins(null); });
}
public void TestAddNote()
{
INoteAccessor accessor = this._provider.GetService <INoteAccessor>();
IUserAccessor userAccessor = this._provider.GetService <IUserAccessor>();
PersistenceContext context = this._provider.GetService <PersistenceContext>();
IUnitOfWork unit = this._provider.GetService <IUnitOfWork>();
var pin = accessor.FindPin("kauf");
var ian = userAccessor.FindUser("ian");
Assert.Equal(7, context.Notes.Count());
Assert.Equal(5, accessor.FindNotes(ian).Count);
accessor.AddNote(new Contracts.DTO.Note()
{
Added = DateTime.Now,
BelongsTo = pin.PinId,
Content = "Testing software late at night, stupid Raikes School curriculum"
});
unit.Commit();
Assert.Equal(8, context.Notes.Count());
Assert.Throws <ArgumentException>(() =>
{
accessor.AddNote(null);
unit.Commit();
});
Assert.Throws <ArgumentException>(() =>
{
accessor.AddNote(new Contracts.DTO.Note()
{
NoteId = "TN4",
Content = "Bad note - duplicate ID",
BelongsTo = pin.PinId
});
unit.Commit();
});
Assert.Throws <ArgumentException>(() =>
{
accessor.AddNote(new Contracts.DTO.Note()
{
Content = "Bad note - no pin"
});
unit.Commit();
});
}
public void TestRemovePin()
{
INoteAccessor accessor = this._provider.GetService <INoteAccessor>();
IUserAccessor userAccessor = this._provider.GetService <IUserAccessor>();
PersistenceContext context = this._provider.GetService <PersistenceContext>();
IUnitOfWork unit = this._provider.GetService <IUnitOfWork>();
var ian = userAccessor.FindUser("ian");
var ianPins = accessor.FindPins(ian);
Assert.Equal(2, ianPins.Count);
Assert.Equal(3, context.Pins.Count());
accessor.RemovePin(ianPins.First());
unit.Commit();
Assert.Equal(2, context.Pins.Count());
ianPins = accessor.FindPins(ian);
Assert.Equal(1, ianPins.Count);
Assert.Throws <ArgumentException>(() =>
{
accessor.RemovePin(null);
unit.Commit();
});
Assert.Throws <ArgumentException>(() =>
{
accessor.RemovePin(new Contracts.DTO.Pin());
unit.Commit();
});
Assert.Throws <ArgumentException>(() =>
{
accessor.RemovePin(new Contracts.DTO.Pin()
{
PinId = "NOTAREALPIN"
});
unit.Commit();
});
}
public Models.User FindUser(string ID)
{
return(_acc.FindUser(ID));
}
private void _UpdateUserAchievements(Activity activity, String uid)
{
var user = _uAcc.FindUser(uid);
var oldDistance = user.LifetimeDistance;
var oldDuration = user.LifetimeDuration;
var oldSteps = user.LifetimeSteps;
var newDistance = oldDistance + activity.Distance;
var newDuration = oldDuration + activity.Duration;
var newSteps = oldSteps + activity.Steps;
user.LifetimeDistance = newDistance;
user.LifetimeDuration = newDuration;
user.LifetimeSteps = newSteps;
_uAcc.UpdateUser(user);
foreach (Badge b in _bAcc.GetBadges())
{
bool justEarned = false;
switch (b.Field)
{
case Field.DISTANCE:
justEarned = (oldDistance < b.Threshold && newDistance >= b.Threshold);
break;
case Field.DURATION:
justEarned = oldDuration < b.Threshold && newDuration >= b.Threshold;
break;
case Field.STEPS:
justEarned = oldSteps < b.Threshold && newSteps >= b.Threshold;
break;
}
if (justEarned)
{
_ubAcc.CreateUserBadge(new UserBadge()
{
BadgeID = b.ID,
DateCompleted = DateTime.Now,
UserID = user.Id,
});
}
}
foreach (Goal b in _gAcc.GetGoals()) // TODO The duplication here feels bad; is there some clean way to give goals and badges the same interface/prevent this?
{
bool justEarned = false;
switch (b.Field)
{
case Field.DISTANCE:
justEarned = (oldDistance < b.Threshold && newDistance >= b.Threshold);
break;
case Field.DURATION:
justEarned = oldDuration < b.Threshold && newDuration >= b.Threshold;
break;
case Field.STEPS:
justEarned = oldSteps < b.Threshold && newSteps >= b.Threshold;
break;
}
if (justEarned)
{
var ug = _ugAcc.GetUserGoal(b.ID, uid);
if (ug != null)
{
ug.DateCompleted = DateTime.Now;
_ugAcc.UpdateUserGoal(ug);
}
}
}
}
public void TestAddPin()
{
INoteAccessor accessor = this._provider.GetService <INoteAccessor>();
IUserAccessor userAccessor = this._provider.GetService <IUserAccessor>();
PersistenceContext context = this._provider.GetService <PersistenceContext>();
IUnitOfWork unit = this._provider.GetService <IUnitOfWork>();
Assert.Equal(3, context.Pins.Count());
var zach = userAccessor.FindUser("zach");
accessor.AddPin(new Contracts.DTO.Pin()
{
BelongsTo = zach.UserId,
Latitude = _lincoln.North,
Longitude = _lincoln.East,
Name = "Lincoln NE"
});
unit.Commit();
Assert.Equal(4, context.Pins.Count());
var zachPins = accessor.FindPins(zach);
Assert.Equal(2, zachPins.Count);
Assert.Throws <ArgumentException>(() =>
{
accessor.AddPin(null);
});
Assert.Throws <ArgumentException>(() =>
{
accessor.AddPin(new Contracts.DTO.Pin()
{
PinId = "kauf",
BelongsTo = zach.UserId,
Latitude = 0,
Longitude = 0,
Name = "Bad pin - duplicate"
});
});
Assert.Throws <ArgumentException>(() =>
{
accessor.AddPin(new Contracts.DTO.Pin()
{
Latitude = 0,
Longitude = 0,
Name = "Bad pin - no owner"
});
});
Assert.Throws <ArgumentException>(() =>
{
accessor.AddPin(new Contracts.DTO.Pin()
{
BelongsTo = zach.UserId,
Name = "Bad pin - no coordinates"
});
});
}
