public void TestIfFindingByIDWorksCorrectly()
{
int id = 1;
var person = extendedDatabase.FindById(id);
Assert.That(person.UserName, Is.EqualTo("Pesho"));
}
public void FindByIdMethodWorkCorrectly()
{
int idForSearch = 23;
Person founfPerson = database.FindById(idForSearch);
Assert.AreEqual(idForSearch, founfPerson.Id);
}
public void AddPersonAddPersonCorectly()
{
person = new Person(id, name);
emptyExtendedDatabase.Add(person);
Assert.AreEqual(person, emptyExtendedDatabase.FindById(id));
}
public void Test13()
{
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
database.FindById(-1);
});
// Assert.That(() => database.FindById(-1), Throws.ArgumentOutOfRangeException.With.Message.EqualTo("Id should be a positive number!")) ;
}
public void If_Negative_Id_Is_Found_Should_Throw_Argument_Out_Of_Range_Exception(long findNegativeId)
{
//Arrange
extendedDatabase.Add(person);
//Act - Assert
Assert.Throws <ArgumentOutOfRangeException>(() => extendedDatabase.FindById(findNegativeId));
}
public void TestIfFindByIdMethodWorksCorrectly()
{
Person expectedPerson = persons[0];
Person actualPerson = database.FindById(0);
Assert.AreEqual(expectedPerson, actualPerson);
}
public void FindByIdOperatonShouldReturnCorrectPerson()
{
// Act
Person expectedPerson = firstPerson;
Person actualPerson = database.FindById(123);
// Assert
Assert.AreEqual(expectedPerson, actualPerson);
}
public void FindByIDUnableToFindID_Should_ThrowException()
{
database.Add(n1claren);
Assert.Throws <InvalidOperationException>(() =>
{
Person somebody = database.FindById(1020304050);
});
}
public void FindById()
{
Person person = new Person(1, "Gosho");
db.Add(person);
Person samePersonExpected = db.FindById(1);
Assert.That(samePersonExpected.Id, Is.EqualTo(person.Id), "Person doesn't match real person.");
}
public void DatabaseShouldThrowExcpFindBy()
{
Assert.Throws <ArgumentNullException>(() => extendedDatabase.FindByUsername(""));
Assert.Throws <InvalidOperationException>(() => extendedDatabase.FindByUsername("Bont"));
Assert.Throws <ArgumentOutOfRangeException>(() => extendedDatabase.FindById(-1));
Assert.Throws <InvalidOperationException>(() => extendedDatabase.FindById(100));
}
public void FindByIdShouldReturnCorrectPerson()
{
Person pesho = new Person(2, "Pesho");
database.Add(pesho);
Person personToFind = database.FindById(2);
Assert.AreEqual(pesho, personToFind);
}
public void FindById_ThrowExeption()
{
var n = 3;
for (int i = 0; i < n; i++)
{
extendedDatabase.Add(new Person(i, $"Name{i}"));
}
extendedDatabase.Remove();
Assert.Throws <InvalidOperationException>(() => extendedDatabase.FindById(n - 1));
}
public void When_UseRemoveMethod_Should_CountreDecrease()
{
int n = 5;
for (int i = 0; i < n; i++)
{
database.Add(new Person(i, $"Angel{i}"));
}
database.Remove();
Assert.That(database.Count, Is.EqualTo(n - 1));
Assert.Throws <InvalidOperationException>(() => database.FindById(n - 1));
}
public void Remove_RemoveElementFromDb()
{
var n = 3;
for (int i = 0; i < n; i++)
{
extendedDb.Add(new Person(i, $"Fresh{i}"));
}
extendedDb.Remove();
Assert.That(extendedDb.Count, Is.EqualTo(n - 1));
Assert.Throws <InvalidOperationException>(() => extendedDb.FindById(n - 1));
}
public void Remove_RemovesElementFromDB()
{
int n = 5;
for (int i = 0; i < n; i++)
{
database.Add(new Person(i, $"Username{i}"));
}
database.Remove();
Assert.That(database.Count, Is.EqualTo(n - 1));
Assert.Throws <InvalidOperationException>(() => database.FindById(n - 1));
}
public void When_RemoveIsValid_RemovesElementFromDatabase()
{
int n = 5;
for (int i = 0; i < n; i++)
{
database.Add(new Person(i, $"username{i}"));
}
database.Remove();
int expectedCount = n - 1;
Assert.AreEqual(expectedCount, database.Count);
Assert.Throws <InvalidOperationException>(() => database.FindById(n - 1));
}
public void RemoveOperationShouldRemoveLastElement()
{
const long lastPersonId = 13579;
const string lastPersonUsername = "******";
const int expectedCount = 2;
//Arrange
List <Person> persons = new List <Person>()
{
new Person(12345, "Ivan"),
new Person(67890, "Asen"),
new Person(13579, "Gosho")
};
ExtendedDatabase.ExtendedDatabase database = new ExtendedDatabase.ExtendedDatabase(persons.ToArray());
//Act
database.Remove();
//Assert
int actualCount = database.Count;
Assert.AreEqual(expectedCount, actualCount);
Assert.Throws <InvalidOperationException>(() => database.FindById(lastPersonId));
Assert.Throws <InvalidOperationException>(() => database.FindByUsername(lastPersonUsername));
}
public void FindByIdNonExistingPersonShouldThrow()
{
var persons = new Person[] { pesho, gosho };
var db = new ExtendedDatabase.ExtendedDatabase(persons);
Assert.That(() => db.FindById(123456789), Throws.InvalidOperationException);
}
public void FindByUsernameNegativeArgumentShouldThrow()
{
var persons = new Person[] { pesho, gosho };
var db = new ExtendedDatabase.ExtendedDatabase(persons);
Assert.That(() => db.FindById(-5), Throws.Exception);
}
public void TestFindByNoId()
{
Assert.That(() => database.FindById(-15),
Throws.Exception.With.Message.Contains("Id should be a positive number!"));
Assert.Throws <InvalidOperationException>(() => this.database.FindById(102));
}
public void FindByIdDoesntContainsId()
{
CreatePeople(5);
ExtendedDatabase.ExtendedDatabase extendedDatabase = new ExtendedDatabase.ExtendedDatabase(people);
Assert.Throws <InvalidOperationException>(() => extendedDatabase.FindById(100));
}
public void FindByIdTakesNegativeId()
{
CreatePeople(5);
ExtendedDatabase.ExtendedDatabase extendedDatabase = new ExtendedDatabase.ExtendedDatabase(people);
Assert.Throws <ArgumentOutOfRangeException>(() => extendedDatabase.FindById(-1));
}
public void Remove_RemovesElementsFromDatabase()
{
this.extendedDatabase.Add(new Person(1, "Momchil"));
this.extendedDatabase.Add(new Person(2, "Emo"));
this.extendedDatabase.Remove();
Assert.Throws <InvalidOperationException>(() => extendedDatabase.FindById(2));
}
public void When_ProvidedDataIsValid_CtorShouldSetItCorrectly()
{
Person firstPerson = new Person(1, "Angel");
Person secondPerson = new Person(2, "Ivan");
Person[] people = new Person[]
{
firstPerson,
secondPerson
};
database = new ExtendedDatabase.ExtendedDatabase(people);
Person dbFirstPerson = database.FindById(firstPerson.Id);
Person dbSecondPerson = database.FindById(secondPerson.Id);
Assert.AreEqual(firstPerson, dbFirstPerson);
Assert.AreEqual(secondPerson, dbSecondPerson);
}
public void FindById_ReturnsExpectedPersonById()
{
Person person = new Person(15, "Kristian");
database.Add(person);
Person dbPerson = database.FindById(person.Id);
Assert.That(person, Is.EqualTo(dbPerson));
}
public void FindByIdExistingPersonShouldReturnPerson()
{
var persons = new Person[] { pesho, gosho };
var db = new ExtendedDatabase.ExtendedDatabase(persons);
var expected = pesho;
var actual = db.FindById(11223344);
Assert.That(actual, Is.EqualTo(expected));
}
public void FindByIdWorksProperly()
{
CreatePeople(5);
ExtendedDatabase.ExtendedDatabase extendedDatabase = new ExtendedDatabase.ExtendedDatabase(people);
Person expectedPerson = new Person(0, "0");
Person actualPerson = extendedDatabase.FindById(0);
Assert.AreEqual(expectedPerson.Id, actualPerson.Id);
Assert.AreEqual(expectedPerson.UserName, actualPerson.UserName);
}
public void CheckFindByIdWorksCorrect()
{
var persons = new Person[] { new Person(1, "A"), new Person(2, "B") };
extendedDatabase = new ExtendedDatabase(persons);
var person = new Person(1, "A");
var personId = person.Id;
var searchedPerson = extendedDatabase.FindById(personId);
Assert.AreEqual(person.Id, searchedPerson.Id);
}
public void CheckFindByIDThrowExceptionIfIdIsNegativeNumber()
{
var persons = new Person[] { new Person(1, "A"), new Person(2, "B") };
extendedDatabase = new ExtendedDatabase(persons);
var searchedId = -1;
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
extendedDatabase.FindById(searchedId);
});
}
public void FindById_ShouldThrowException_WhenNegativeIdIsProvided()
{
//Arrange
var database = new ExtendedDatabase.ExtendedDatabase();
var userOne = new Person(1, "UserOne");
//Act
database.Add(userOne);
//Assert
Assert.Throws <ArgumentOutOfRangeException>(() => database.FindById(-1));
}