public async Task ServerListCommandHandler_HandlesNotLocal()
{
ServerListCommand command = new ServerListCommand()
{
FetchLocal = false
};
string serversPath = JsonConvert.DeserializeObject <StorageSettings>(new StreamReader("./StorageSettings.json").ReadToEnd()).ServerSavePath;
if (File.Exists(serversPath))
{
File.Delete(serversPath);
}
await AbstractCommandHandler.StartWork(command, ContainerConfig.Configure());
IEnumerable <Server> servers = null;
using (var sr = new StreamReader(serversPath))
{
servers = JsonConvert.DeserializeObject <IEnumerable <Server> >(sr.ReadToEnd());
}
Assert.NotNull(servers);
Assert.NotEmpty(servers);
}
public async Task InvAsync_Local_True_Expected_Result_1()
{
_logger.Responses.Clear();
TestConsole console = new TestConsole();
bool local = true;
ServerListCommand command = new ServerListCommand(local, _store, _logger, _data);
var result = await command.InvAsync(console);
Assert.AreEqual(1, result);
}
public async Task InvAsync_Local_False_And_AuthServer_Username_Wrong_Expected_Result_0()
{
_logger.Responses.Clear();
TestConsole console = new TestConsole();
bool local = false;
_data.User.UserName = "******";
ServerListCommand command = new ServerListCommand(local, _store, _logger, _data);
var result = await command.InvAsync(console);
Assert.AreEqual(0, result);
}
public async Task InvAsync_Local_False_Expected_Result_1_AND_Servers_In_DataStore()
{
_logger.Responses.Clear();
TestConsole console = new TestConsole();
bool local = false;
_data.Servers.Clear();
_store.Write(_data);
ServerListCommand command = new ServerListCommand(local, _store, _logger, _data);
var result = await command.InvAsync(console);
_data = _store.Read();
Assert.AreEqual(1, result);
Assert.IsTrue(_data.Servers.Count > 0);
}
public static async Task <int> MainAsync(string[] args)
{
//Default data source.
var dataFileName = ConfigurationManager.AppSettings["dataFilename"];
// Default format of data storage (Xml, Json atm.)
Type dataStoreFormat = typeof(Xmlformat);
// Default data type
Type dataType = typeof(AppData);
// Initiate data manager class
var store = new FileStore(dataFileName, dataStoreFormat, dataType);
// Initiate Application logger
var logger = new AppLogger("log.txt");
// Reading data of default data type from default source.
// If commands needs to operate with different data type and/or location,
// store.Read() should be called at the begining of Command handler InvokeAsync method.
var data = store.Read();
if (data == null)
{
// Log warning and go on with code
logger.Responses.Add(new LogResponse {
Logger = "Main",
MessageLogged = false,
ResponseMessage = "Can't load/missing application data needed for at least some commands."
});
}
logger.Write(MsgCategory.Info, "Application started.", console: false, file: true);
// Building command line commands and parsing provided arguments
try
{
RootCommand command = new RootCommand
{
ServerListCommand.Create(),
ConfigCommand.Create(),
ExportCommand.Create(),
LoggerCommand.Create()
};
Parser parser = BuildParser(command, logger, store, data);
await parser.InvokeAsync(args);
}
catch (Exception ex)
{
logger.Write(MsgCategory.Error, "Application terminated: " + ex.Message, console: true, file: true);
return(0);
}
// If app settings for warnings are enabled
// Informing user about warnings before exit
var appWarn = logger.Responses.Where(rs => rs.MessageLogged == false).Distinct().ToList();
if (appWarn.Count > 0)
{
logger.Write(MsgCategory.Info, "Application completed with warnings:", console: true, file: false);
foreach (var response in appWarn)
{
logger.Write(MsgCategory.Warning, message: response.Logger + ": " + response.ResponseMessage, console: true, file: true);
}
return(1);
}
logger.Write(MsgCategory.Info, "Application completed.", console: false, file: true);
return(1);
}
public void TestInitialize()
{
credentialsToReturn = new Credentials
{
Username = "******",
Password = "******"
};
serversToReturn = new List <Server>()
{
new Server {
Name = "First server"
},
new Server {
Name = "Second server"
},
new Server {
Name = "Third server"
}
};
serverApiAuthorizeCredentials = null;
savedItems = null;
displyedItems = null;
loggerMock = new Mock <ILogger>(MockBehavior.Loose);
loggerMock.Setup(l => l.ForContext <ServerListCommand>())
.Returns(loggerMock.Object);
credentialsRepositoryMock = new Mock <IRepository <Credentials> >(MockBehavior.Strict);
credentialsRepositoryMock.Setup(r => r.GetAll())
.Returns(new[] { credentialsToReturn });
repositoryMock = new Mock <IRepository <Server> >(MockBehavior.Strict);
repositoryMock.Setup(r => r.GetAll())
.Returns(new List <Server>(serversToReturn));
repositoryMock.Setup(r => r.Update(It.IsAny <IEnumerable <Server> >()))
.Callback <IEnumerable <Server> >(items =>
{
savedItems = items.ToList();
});
serverApiMock = new Mock <IServerApi>(MockBehavior.Strict);
serverApiMock.Setup(a => a.AuthorizeAsync(It.IsAny <Credentials>()))
.Callback <Credentials>(credentials =>
{
serverApiAuthorizeCredentials = credentials;
})
.Returns(Task.CompletedTask);
serverApiMock.Setup(a => a.GetServersAsync())
.ReturnsAsync(new List <Server>(serversToReturn).AsEnumerable());
serverPresenterMock = new Mock <IServerPresenter>(MockBehavior.Strict);
serverPresenterMock.Setup(p => p.Display(It.IsAny <IEnumerable <Server> >()))
.Callback <IEnumerable <Server> >(items =>
{
displyedItems = items.ToList();
});
command = new ServerListCommand(loggerMock.Object, serverApiMock.Object, repositoryMock.Object, credentialsRepositoryMock.Object, serverPresenterMock.Object);
servicesMock = new Mock <IServiceProvider>(MockBehavior.Loose);
servicesMock.Setup(s => s.GetService(typeof(ServerListCommand)))
.Returns(command);
cliApp = new CommandLineApplication();
ServerListCommand.Configure(cliApp, servicesMock.Object);
}
