public void PersonConverterTest()
{
var inputter = new Mock <IPersonInputter>();
var parser = new Mock <IPersonParser>();
var outputter = new Mock <IPersonOutputter>();
inputter
.Setup(i => i.GetPersonData())
.Returns(tmpStrArray);
parser
.Setup(p => p.ParseToPersonEntity(tmpStrArray))
.Returns(tmpPersonArray);
var converter = new PersonConverter(inputter.Object, parser.Object, outputter.Object);
converter.Convert();
inputter.Verify(i => i.GetPersonData(), Times.Once);
parser.Verify(p => p.ParseToPersonEntity(tmpStrArray), Times.Once);
outputter.Verify(o => o.OutputPersons(tmpPersonArray), Times.Once);
Assert.Throws <ArgumentNullException>(
"inputter", () => new PersonConverter(null, parser.Object, outputter.Object));
Assert.Throws <ArgumentNullException>(
"parser", () => new PersonConverter(inputter.Object, null, outputter.Object));
Assert.Throws <ArgumentNullException>(
"outputter", () => new PersonConverter(inputter.Object, parser.Object, null));
}
public void TestPerson()
{
IDataAccessor da = personDA;
read(da);
DataTable table = dataSet.person;
Assert.AreEqual(0, table.Rows.Count, "Table is empty");
DataRow newRow = table.NewRow();
PersonConverter.toDataRow(newRow, new Person("TestPerson", "password", Person.PersonType.REGULAR));
table.Rows.Add(newRow);
write(da);
Assert.AreEqual(1, table.Rows.Count, "Added one record");
DataRow firstRow = table.Rows[0];
Assert.AreEqual("TestPerson", firstRow["name"], "Names are equals");
firstRow["name"] = "RenameTest";
write(da);
List <DataRow> findList = table.Select("name = 'RenameTest'").OfType <DataRow>().ToList();
Assert.AreEqual("RenameTest", findList[0]["name"], "Names are equals");
firstRow.Delete();
write(da);
dataSet = new UPrintDataSet();
read(da);
int count = dataSet.person.Rows.Count;
Assert.AreEqual(0, count);
}
public static void LoadFakesForPeople(MySqlConnection connection, IEnumerable <TVTPerson> people)
{
var command = connection.CreateCommand();
command.CommandText = "SELECT * FROM tvt_convert WHERE type = 'actor'";
var Reader = command.ExecuteReader();
try
{
while (Reader.Read())
{
var oldValue = Reader.GetString("old");
var newValue = Reader.GetString("new");
var foundPeople = people.Where(x => x.FullName == oldValue);
foreach (var person in foundPeople)
{
PersonConverter.ConvertFakeFullname(person, newValue);
}
foundPeople = people.Where(x => x.FakeFullName == " " && x.FullName.Contains(oldValue));
foreach (var person in foundPeople)
{
PersonConverter.ConvertFakeFullname(person, newValue);
}
}
}
finally
{
if (Reader != null && !Reader.IsClosed)
{
Reader.Close();
}
}
}
public PersonBusinessImpl(IRepository <Person> repository)
{
_repository = repository;
//Instanciando o nosso converter
_converter = new PersonConverter();
}
public void TestTask()
{
IDataAccessor da = taskDA;
read(da);
DataTable table = dataSet.task;
Assert.AreEqual(0, table.Rows.Count, "Table is empty");
DataRow personRow = dataSet.person.NewRow();
Person person = new Person("person", "", Person.PersonType.ADMIN);
PersonConverter.toDataRow(personRow, person);
dataSet.person.Rows.Add(personRow);
write(personDA);
DataRow modelRow = dataSet.model.NewRow();
Model model = new Model("model");
ModelConverter.toDataRow(modelRow, model);
dataSet.model.Rows.Add(modelRow);
write(modelDA);
DataRow jobRow = dataSet.job.NewRow();
Job job = new Job(0, "job", DateTime.Now, "test", 0, 0);
JobConverter.toDataRow(jobRow, job);
dataSet.job.Rows.Add(jobRow);
write(jobDA);
DataRow printerRow = dataSet.printer.NewRow();
Printer printer = new Printer("printer");
PrinterConverter.toDataRow(printerRow, printer);
dataSet.printer.Rows.Add(printerRow);
write(printerDA);
DataRow newRow = table.NewRow();
TaskConverter.toDataRow(newRow, new Task(0, "TestTask", 0, 0, DateTime.Now, DateTime.Now, DateTime.Now, Task.TaskStatus.NEW, 0));
table.Rows.Add(newRow);
write(da);
Assert.AreEqual(1, table.Rows.Count, "Added one record");
DataRow firstRow = table.Rows[0];
Assert.AreEqual("TestTask", firstRow["name"], "Names are equals");
firstRow["name"] = "RenameTest";
write(da);
List <DataRow> findList = table.Select("name = 'RenameTest'").OfType <DataRow>().ToList();
Assert.AreEqual("RenameTest", findList[0]["name"], "Names are equals");
firstRow.Delete();
write(da);
read(da);
int count = dataSet.task.Rows.Count;
Assert.AreEqual(0, count);
}
public void CanSerializeOneName()
{
var johnSmith = new Person("John", "Smith");
var listToSerialize = new List <Person> {
johnSmith
};
var filePath = TestHelper.GetResourcePath("SinglePersonDeserializationTest.txt");
var fileContents = PersonConverter.SerializeToFile(listToSerialize, filePath);
Assert.AreEqual("John Smith", fileContents);
}
public void CanDeserializeOneName()
{
var johnSmith = new Person("John", "Smith");
var expectedList = new List <Person> {
johnSmith
};
var filePath = TestHelper.GetResourcePath("SinglePersonTest.txt");
var actualList = PersonConverter.DeserializeFromFile(filePath);
Assert.AreEqual(expectedList, actualList);
}
public static string ExecuteSort(string inputFile, string outputFile = null)
{
var persons = PersonConverter.DeserializeFromFile(inputFile);
var nameSorter = new PersonComparer();
persons.Sort(nameSorter);
var fileContents = PersonConverter.SerializeToFile(persons, outputFile);
return(fileContents);
}
public void CanSerializeManyNames()
{
var johnSmith = new Person("John", "Smith");
var johnAardvarkJones = new Person("John Aardvark", "Jones");
var bobBarrymoreFredDylan = new Person("Bob Barrymore Fred", "Dylan");
var listToSerialize = new List <Person> {
johnSmith, johnAardvarkJones, bobBarrymoreFredDylan
};
var filePath = TestHelper.GetResourcePath("SinglePersonDeserializationTest.txt");
var fileContents = PersonConverter.SerializeToFile(listToSerialize, filePath);
Assert.AreEqual($"John Smith{Environment.NewLine}John Aardvark Jones{Environment.NewLine}Bob Barrymore Fred Dylan", fileContents);
}
public void CanDeserializeManyNames()
{
var johnSmith = new Person("John", "Smith");
var johnAardvarkJones = new Person("John Aardvark", "Jones");
var bobBarrymoreFredDylan = new Person("Bob Barrymore Fred", "Dylan");
var expectedList = new List <Person> {
johnSmith, johnAardvarkJones, bobBarrymoreFredDylan
};
var filePath = TestHelper.GetResourcePath("MultiplePersonTest.txt");
var actualList = PersonConverter.DeserializeFromFile(filePath);
Assert.AreEqual(expectedList, actualList);
}
public void TestJob()
{
IDataAccessor da = jobDA;
read(da);
Assert.AreEqual(0, dataSet.job.Rows.Count, "Table is empty");
DataRow personRow = dataSet.person.NewRow();
Person person = new Person("person", "", Person.PersonType.ADMIN);
PersonConverter.toDataRow(personRow, person);
dataSet.person.Rows.Add(personRow);
write(personDA);
DataRow modelRow = dataSet.model.NewRow();
Model model = new Model("model");
ModelConverter.toDataRow(modelRow, model);
dataSet.model.Rows.Add(modelRow);
write(modelDA);
read(modelDA);
DataRow newRow = dataSet.job.NewRow();
JobConverter.toDataRow(newRow, new Job(0, "TestJob", DateTime.Now, "test", 0, 0));
dataSet.job.Rows.Add(newRow);
write(da);
read(da);
Assert.AreEqual(1, dataSet.job.Rows.Count, "Added one record");
DataRow firstRow = dataSet.job.Rows[0];
Assert.AreEqual("TestJob", firstRow["name"], "Names are equals");
firstRow["name"] = "RenameTest";
write(da);
read(da);
List <DataRow> findList = dataSet.job.Select("name = 'RenameTest'").OfType <DataRow>().ToList();
Assert.AreEqual("RenameTest", findList[0]["name"], "Names are equals");
firstRow = dataSet.job.Rows[0];
firstRow.Delete();
write(da);
read(da);
int count = dataSet.job.Rows.Count;
Assert.AreEqual(0, count);
}
public TVTPerson RegisterActor(Cast cast)
{
var person = Database.GetPersonByTmdbId(cast.id);
if (person == null)
{
person = new TVTPerson();
PersonConverter.ConvertFullname(person, cast.name);
person.TmdbId = cast.id;
person.Functions.Add(TVTPersonFunction.Actor);
person.AdditionalInfo = cast.character;
RegisterPerson(person, cast.id);
Database.AddPerson(person);
}
return(person);
}
public TVTPerson RegisterDirector(Crew crew)
{
var person = Database.GetPersonByTmdbId(crew.id);
if (person == null)
{
person = new TVTPerson();
PersonConverter.ConvertFullname(person, crew.name);
person.TmdbId = crew.id;
person.Functions.Add(TVTPersonFunction.Director);
person.AdditionalInfo = crew.job + "/" + crew.department;
RegisterPerson(person, crew.id);
Database.AddPerson(person);
}
return(person);
}
public PersonServiceImpl(IPersonRepository repository)
{
_repository = repository;
_converter = new PersonConverter();
}
public PersonBusinessImpl(IRepository <Person> repository)
{
_repository = repository;
_converter = new PersonConverter();
}
public PersonBusinessImpl(
IRepository <Person> personRepository)
{
_personRepository = personRepository;
_personConverter = new PersonConverter();
}
public PersonBusiness(IPersonRepository repository)
{
_repository = repository;
_converter = new PersonConverter();
}
public PersonBusiness(IRepository <Person> repository)
{
this.repository = repository;
this.converter = new PersonConverter();
}
public PersonServiceImplementation(IRepository <Person> repository)
{
_repository = repository;
_converter = new PersonConverter();
}
public PersonBusinessImpl(IPersonRepository repository)
{
this.repository = repository;
this.converter = new PersonConverter();
}
public PersonService(IPersonRepository repo)
{
this.repo = repo;
this.converter = new PersonConverter();
}
public PersonBusinessImplementation(IRepository <Person> repository)
{
//Context injection
_repository = repository;
_converter = new PersonConverter();
}
public PersonBussinesImp(IPersonRepository repository)
{
_repository = repository;
_personConverter = new PersonConverter();
}
public PersonBusiness(IPersonRepository personRepository, PersonConverter converter)
{
_personRepository = personRepository;
_converter = converter;
}
public PersonService(IGenericRepository <Person> repository)
{
_repository = repository;
_converter = new PersonConverter();
}
public PersonController(IPersonService iPersonService)
{
_personService = iPersonService;
_personConverter = new PersonConverter();
}
public PersonServiceImpl(IPersonRepository repository)
{
this.repository = repository;
// Build the PersonConventer Instance
this.converter = new PersonConverter();
}
public PersonBusinessImplementation(IRepository <Person> personRepository)
{
_personRepository = personRepository;
_converter = new PersonConverter();
}
public PersonBusinessImplementation(IPersonRepository repository)
{
_repository = repository;
_converter = new PersonConverter();
}
public PersonBusiness(IBaseRepository <Person> repo)
{
_repo = repo;
_converter = new PersonConverter();
}
