public void ShouldNotGetStackAndLogError()
{
MockedDatabase <Stack> database;
StackModule module;
MemoryLogger logger;
logger = new MemoryLogger();
database = new MockedDatabase <Stack>(true, 1, (t) => new Stack()
{
StackID = t
});
module = new StackModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.GetStack(1));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
logger = new MemoryLogger();
database = new MockedDatabase <Stack>(true, 1, (t) => new Stack()
{
StackID = t
});
module = new StackModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.GetStack(1, ResourceTypeIDs.Coal));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
public void ShouldUpdateWorkerResourceTypeID()
{
MockedDatabase <Worker> database;
WorkerModule module;
database = new MockedDatabase <Worker>(false, 1, (t) => new Worker()
{
WorkerID = t, PlanetID = 0
});
module = new WorkerModule(NullLogger.Instance, database);
module.UpdateWorker(1, ResourceTypeIDs.Wood);
Assert.AreEqual(1, database.UpdatedCount);
}
public void ShouldUpdateStack()
{
MockedDatabase <Stack> database;
StackModule module;
database = new MockedDatabase <Stack>(false, 1, (t) => new Stack()
{
StackID = t, BuildingID = 0, ResourceTypeID = 0, Quantity = 5
});
module = new StackModule(NullLogger.Instance, database);
module.UpdateStack(1, 2);
Assert.AreEqual(1, database.UpdatedCount);
}
public void ShouldDeleteTask()
{
MockedDatabase <Task> database;
TaskModule module;
database = new MockedDatabase <Task>(false, 1, (t) => new Task()
{
TaskID = t
});
module = new TaskModule(NullLogger.Instance, database);
module.DeleteTask(1);
Assert.AreEqual(1, database.DeletedCount);
}
public void ShouldUpdateBuilding()
{
MockedDatabase <Building> database;
BuildingModule module;
database = new MockedDatabase <Building>(false, 1, (t) => new Building()
{
BuildingID = t
});
module = new BuildingModule(NullLogger.Instance, database);
module.UpdateBuilding(0, 10);
Assert.AreEqual(1, database.UpdatedCount);
}
public void ShouldNotGetBuildingUsingCoordinates()
{
MockedDatabase <Building> database;
BuildingModule module;
Building result;
database = new MockedDatabase <Building>(false, 0, (t) => new Building()
{
BuildingID = t, X = 3, Y = 4
});
module = new BuildingModule(NullLogger.Instance, database);
result = module.GetBuilding(1, 4, 3);
Assert.IsNull(result);
}
public void ShouldNotGetCellUsingCoordinates()
{
MockedDatabase <Cell> database;
CellModule module;
Cell result;
database = new MockedDatabase <Cell>(false, 0, (t) => new Cell()
{
CellID = t, X = 3, Y = 4
});
module = new CellModule(NullLogger.Instance, database);
result = module.GetCell(1, 4, 3);
Assert.IsNull(result);
}
public void ShouldGetWorker()
{
MockedDatabase <Worker> database;
WorkerModule module;
Worker result;
database = new MockedDatabase <Worker>(false, 1, (t) => new Worker()
{
WorkerID = t
});
module = new WorkerModule(NullLogger.Instance, database);
result = module.GetWorker(1);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.WorkerID);
}
public void ShouldGetProduct()
{
MockedDatabase <Product> database;
ProductModule module;
Product result;
database = new MockedDatabase <Product>(false, 1, (t) => new Product()
{
ProductID = t
});
module = new ProductModule(NullLogger.Instance, database);
result = module.GetProduct(1);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.ProductID);
}
public void ShouldFindStack()
{
MockedDatabase <Stack> database;
StackModule module;
Stack result;
database = new MockedDatabase <Stack>(false, 1, (t) => new Stack()
{
StackID = t
});
module = new StackModule(NullLogger.Instance, database);
result = module.FindStack(1, ResourceTypeIDs.Coal);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.StackID);
}
public void ShouldGetPhrase()
{
MockedDatabase <Phrase> database;
PhraseModule module;
Phrase result;
database = new MockedDatabase <Phrase>(false, 1, (t) => new Phrase()
{
Key = t.ToString(), CountryCode = "EN"
});
module = new PhraseModule(NullLogger.Instance, database);
result = module.GetPhrase("1", "EN");
Assert.IsNotNull(result);
Assert.AreEqual("0", result.Key);
}
public void ShouldGetLastTask()
{
MockedDatabase <Task> database;
TaskModule module;
Task result;
database = new MockedDatabase <Task>(false, 5, (t) => new Task()
{
TaskID = t
});
module = new TaskModule(NullLogger.Instance, database);
result = module.GetLastTask(1);
Assert.IsNotNull(result);
Assert.AreEqual(4, result.TaskID);
}
public void ShouldGetBuilding()
{
MockedDatabase <Building> database;
BuildingModule module;
Building result;
database = new MockedDatabase <Building>(false, 1, (t) => new Building()
{
BuildingID = t
});
module = new BuildingModule(NullLogger.Instance, database);
result = module.GetBuilding(1);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.BuildingID);
}
public void ShouldNotGetCellUsingCoordinateAndLogError()
{
MockedDatabase <Cell> database;
CellModule module;
MemoryLogger logger;
logger = new MemoryLogger();
database = new MockedDatabase <Cell>(true, 1, (t) => new Cell()
{
CellID = t
});
module = new CellModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.GetCell(1, 3, 4));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
public void ShouldGetTaskType()
{
MockedDatabase <TaskType> database;
TaskTypeModule module;
TaskType result;
database = new MockedDatabase <TaskType>(false, 1, (t) => new TaskType()
{
TaskTypeID = (TaskTypeIDs)t
});
module = new TaskTypeModule(NullLogger.Instance, database);
result = module.GetTaskType(TaskTypeIDs.Idle);
Assert.IsNotNull(result);
Assert.AreEqual(TaskTypeIDs.Idle, result.TaskTypeID);
}
public void ShouldGetBuildingType()
{
MockedDatabase <BuildingType> database;
BuildingTypeModule module;
BuildingType result;
database = new MockedDatabase <BuildingType>(false, 1, (t) => new BuildingType()
{
BuildingTypeID = (BuildingTypeIDs)t
});
module = new BuildingTypeModule(NullLogger.Instance, database);
result = module.GetBuildingType(BuildingTypeIDs.Forest);
Assert.IsNotNull(result);
Assert.AreEqual(BuildingTypeIDs.Forest, result.BuildingTypeID);
}
public void ShouldGetResourceType()
{
MockedDatabase <ResourceType> database;
ResourceTypeModule module;
ResourceType result;
database = new MockedDatabase <ResourceType>(false, 1, (t) => new ResourceType()
{
ResourceTypeID = (ResourceTypeIDs)t
});
module = new ResourceTypeModule(NullLogger.Instance, database);
result = module.GetResourceType(ResourceTypeIDs.Wood);
Assert.IsNotNull(result);
Assert.AreEqual(ResourceTypeIDs.Wood, result.ResourceTypeID);
}
public void ShouldGetIngredient()
{
MockedDatabase <Ingredient> database;
IngredientModule module;
Ingredient result;
database = new MockedDatabase <Ingredient>(false, 1, (t) => new Ingredient()
{
IngredientID = t
});
module = new IngredientModule(NullLogger.Instance, database);
result = module.GetIngredient(1);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.IngredientID);
}
public void ShouldGetMaterial()
{
MockedDatabase <Material> database;
MaterialModule module;
Material result;
database = new MockedDatabase <Material>(false, 1, (t) => new Material()
{
MaterialID = t
});
module = new MaterialModule(NullLogger.Instance, database);
result = module.GetMaterial(1);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.MaterialID);
}
public void ShouldNotUpdateBuildingAndLogError()
{
MockedDatabase <Building> database;
BuildingModule module;
MemoryLogger logger;
logger = new MemoryLogger();
database = new MockedDatabase <Building>(true, 3, (t) => new Building()
{
BuildingID = t
});
module = new BuildingModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.UpdateBuilding(0, 1));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
public void ShouldCreateTaskType()
{
MockedDatabase <TaskType> database;
TaskTypeModule module;
TaskType result;
database = new MockedDatabase <TaskType>(false, 1, (t) => new TaskType()
{
TaskTypeID = (TaskTypeIDs)t
});
module = new TaskTypeModule(NullLogger.Instance, database);
result = module.CreateTaskType(TaskTypeIDs.Build, "New");
Assert.IsNotNull(result);
Assert.AreEqual(TaskTypeIDs.Build, result.TaskTypeID);
Assert.AreEqual(1, database.InsertedCount);
}
public void ShouldNotGetTaskTypesAndLogError()
{
MockedDatabase <TaskType> database;
TaskTypeModule module;
MemoryLogger logger;
logger = new MemoryLogger();
database = new MockedDatabase <TaskType>(true, 3, (t) => new TaskType()
{
TaskTypeID = (TaskTypeIDs)t
});
module = new TaskTypeModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.GetTaskTypes());
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
public void ShouldCreateBuildingType()
{
MockedDatabase <BuildingType> database;
BuildingTypeModule module;
BuildingType result;
database = new MockedDatabase <BuildingType>(false, 1, (t) => new BuildingType()
{
BuildingTypeID = (BuildingTypeIDs)t
});
module = new BuildingTypeModule(NullLogger.Instance, database);
result = module.CreateBuildingType(BuildingTypeIDs.Sawmill, "New", 0, 10, false, false);
Assert.IsNotNull(result);
Assert.AreEqual(BuildingTypeIDs.Sawmill, result.BuildingTypeID);
Assert.AreEqual(1, database.InsertedCount);
}
public void ShouldCreateIngredient()
{
MockedDatabase <Ingredient> database;
IngredientModule module;
Ingredient result;
database = new MockedDatabase <Ingredient>(false, 1, (t) => new Ingredient()
{
IngredientID = t
});
module = new IngredientModule(NullLogger.Instance, database);
result = module.CreateIngredient(BuildingTypeIDs.Forest, ResourceTypeIDs.Wood, 1);
Assert.IsNotNull(result);
Assert.AreEqual(ResourceTypeIDs.Wood, result.ResourceTypeID);
Assert.AreEqual(1, database.InsertedCount);
}
public void ShouldNotGetIngredientsAndLogError()
{
MockedDatabase <Ingredient> database;
IngredientModule module;
MemoryLogger logger;
logger = new MemoryLogger();
database = new MockedDatabase <Ingredient>(true, 3, (t) => new Ingredient()
{
IngredientID = t
});
module = new IngredientModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.GetIngredients(BuildingTypeIDs.Stockpile));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
public void ShouldCreateMaterial()
{
MockedDatabase <Material> database;
MaterialModule module;
Material result;
database = new MockedDatabase <Material>(false, 1, (t) => new Material()
{
MaterialID = t
});
module = new MaterialModule(NullLogger.Instance, database);
result = module.CreateMaterial(BuildingTypeIDs.Forest, ResourceTypeIDs.Wood, 1);
Assert.IsNotNull(result);
Assert.AreEqual(ResourceTypeIDs.Wood, result.ResourceTypeID);
Assert.AreEqual(1, database.InsertedCount);
}
public void ShouldNotGetMaterialsAndLogError()
{
MockedDatabase <Material> database;
MaterialModule module;
MemoryLogger logger;
logger = new MemoryLogger();
database = new MockedDatabase <Material>(true, 3, (t) => new Material()
{
MaterialID = t
});
module = new MaterialModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.GetMaterials(BuildingTypeIDs.Sawmill));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
public void ShouldNotUpdateWorkerResourceTypeIDAndLogError()
{
MockedDatabase <Worker> database;
WorkerModule module;
MemoryLogger logger;
logger = new MemoryLogger();
database = new MockedDatabase <Worker>(true, 1, (t) => new Worker()
{
WorkerID = t, PlanetID = 0
});
module = new WorkerModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.UpdateWorker(0, ResourceTypeIDs.Wood));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
public void ShouldCreateCell()
{
MockedDatabase <Cell> database;
CellModule module;
Cell result;
database = new MockedDatabase <Cell>(false, 1, (t) => new Cell()
{
CellID = t
});
module = new CellModule(NullLogger.Instance, database);
result = module.CreateCell(1, 10, 10);
Assert.IsNotNull(result);
Assert.AreEqual(10, result.X);
Assert.AreEqual(1, database.InsertedCount);
}
public void ShouldNotGetWorkersAndLogError()
{
MockedDatabase <Worker> database;
WorkerModule module;
MemoryLogger logger;
logger = new MemoryLogger();
database = new MockedDatabase <Worker>(true, 3, (t) => new Worker()
{
WorkerID = t
});
module = new WorkerModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.GetWorkers(1));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
