/// <summary>
/// Manage <paramref name="strategy"/>'s "overwrite" definition by deleting,
/// ignoring or throwing an error for an existing <paramref name="destination"/> file.
/// </summary>
/// <param name="destination">Destination file</param>
/// <param name="strategy">Applied strategy</param>
/// <returns>True if the overwrite should be skipped, otherwise false</returns>
private static bool ManageOverwrite(string destination, FileStrategy strategy)
{
if (!File.Exists(destination))
{
return(false);
}
if (strategy.Overwrite == "true")
{
try
{
File.Delete(destination);
}
catch (Exception)
{
throw new Exception(
String.Format(
"FileStrategy failure. Unable to overwrite {0}. The path could be unaccessible or the file is in use.",
destination));
}
return(false);
}
if (strategy.Overwrite == "false")
{
throw new Exception(
String.Format(
@"FileStrategy failure. The file at path {0} already exists. Remove the file or change the ""{1}"" strategy attribute for ""{2}"" element.",
destination, Resources.OverwriteAttribute, strategy.Type));
}
return(strategy.Overwrite == "skip" || strategy.Overwrite == "continue");
}
public static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Logger logger = LoggerCreator.LoggerFactory("test", LogStrategy.FILE);
FileStrategy strategy = new FileStrategy(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
Logger loggers = LoggerCreator.LoggerFactory("test", strategy);
logger.Info(new Record("Bu Bir Test Info Logudur!!!"));
logger.Warning(new Record("Bu Bir Test Warning Logudur!!!"));
Record record = new Record("This is a Test Log");
logger.Warning(record);
record.setLevel(LogLevel.Alert);
logger.Log(record);
List <IRecord> logs = logger.getLogs();
if (logs != null)
{
foreach (var item in logs)
{
Console.WriteLine(item.getMessage() + " - " + item.getLevel());
}
}
else
{
Console.WriteLine("No Log Found!!");
}
Console.ReadKey();
}
private static void ManageGroupedFiles(string filename, string sourceDir, string destinationDir,
FileStrategy strategy)
{
var filenameNoExt = Path.GetFileNameWithoutExtension(filename);
var sourceFiles = strategy.With.Split(',').Select(q =>
String.Format(@"{0}.{1}", filenameNoExt, q.Trim()));
foreach (var sourceFile in sourceFiles)
{
var source = Path.Combine(sourceDir, sourceFile);
if (!File.Exists(source))
{
continue;
}
var destination = Path.Combine(destinationDir, sourceFile);
// Manage strategy's "overwrite" definition by deleting, ignoring
// or throw an error for an existing target file.
var shouldSkip = ManageOverwrite(destination, strategy);
if (shouldSkip)
{
continue;
}
try
{
switch (strategy.Type)
{
case "move":
File.Move(source, destination);
break;
case "copy":
File.Copy(source, destination);
break;
}
}
catch (Exception)
{
throw new Exception(
String.Format(
@"FileStrategy failure. Unable to {0} related file ""{1}"" to ""{2}"". The path could be unaccessible or the source file is open.",
strategy.Type, source, destinationDir));
}
}
}
public static Logger LoggerFactory(string name, LogStrategy strategy = LogStrategy.STATIC)
{
ILogStrategy _strategy;
switch (strategy)
{
case LogStrategy.STATIC:
_strategy = new StaticStrategy();
break;
case LogStrategy.HTTP_API:
_strategy = new APIStrategy();
break;
case LogStrategy.FILE:
_strategy = new FileStrategy();
break;
default:
throw new Exception("Invalid Log Strategy!!");
break;
}
return(new Logger(name, _strategy));
}
public void Can_Load_Requests_XML()
{
//preparation - create context with created options passed as argument
RequestContext context = new RequestContext(CreateNewContextOptions());
List <IFormFile> formFiles = new List <IFormFile>();
//arrange
var fileMock = new Mock <IFormFile>();
RequestsXml requests = new RequestsXml
{
Requests = new List <RequestXml>
{
new RequestXml {
ClientId = "1",
Name = "test",
Price = "2.2",
Quantity = "10",
RequestId = "1"
},
new RequestXml {
ClientId = "1",
Name = "test",
Price = "2.2",
Quantity = "100",
RequestId = "1"
}
}
};
XmlSerializer serializer = new XmlSerializer(typeof(RequestsXml));
var requestXmlTest = "";
using (var sww = new StringWriter())
using (XmlWriter xmlWriter = XmlWriter.Create(sww))
{
serializer.Serialize(xmlWriter, requests);
requestXmlTest = sww.ToString(); // Your XML
}
//setup mock file using a memory stream
var content = requestXmlTest;
var fileName = "test.xml";
var ms = new MemoryStream();
var writer = new StreamWriter(ms);
writer.Write(content);
writer.Flush();
ms.Position = 0;
fileMock.Setup(_ => _.OpenReadStream()).Returns(ms);
fileMock.Setup(_ => _.FileName).Returns(fileName);
fileMock.Setup(_ => _.ContentType).Returns("text/xml");
fileMock.Setup(_ => _.Length).Returns(ms.Length);
formFiles.Add(fileMock.Object);
Mock <IOrderService> mockOrderService = new Mock <IOrderService>();
Mock <IEnumerable <IFileService> > mockFileServices = new Mock <IEnumerable <IFileService> >();
IEnumerable <IFileService> services = new List <IFileService>
{
new JsonService(context),
new XmlService(context),
new CsvService(context)
};
//mockFileServices.Setup(m => m.FirstOrDefault(It.IsAny<Expression<Func<IFileService, bool>>>()))
// .Returns(services.FirstOrDefault());
FileStrategy fileStrategy = new FileStrategy(services);
Mock <IFileStrategy> mockStrategy = new Mock <IFileStrategy>();
//target - create app controller, whose method will be tested
FileController fileController = new FileController(fileStrategy);
fileController.FilesLoad(formFiles);
var requestTest = (from r in context.Requests
where r.ClientId == 1
select r);
var orderTest = (from o in context.Orders
where o.ClientId == 1
select o);
Assert.AreEqual(2, requestTest.Count());
Assert.AreEqual(1, orderTest.Count());
Assert.AreEqual("test", requestTest.First().Name);
Assert.AreEqual(242, (int)orderTest.First().Amount);
}
