public void Should_Create_Correct_LogDTO_Object(int id)
{
var fakeContext = new FakeContext("LogDTOTest");
fakeContext.FillWithAll();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile <AutoMapperProfile>();;
});
var mapper = mockMapper.CreateMapper();
var testLog = service.GetFullLog(id);
var logDTO = mapper.Map <Log, LogDTO>(testLog);
Assert.IsType <LogDTO>(logDTO);
Assert.Equal(testLog.Id, logDTO.Id);
Assert.Equal(testLog.Name, logDTO.Name);
Assert.Equal(testLog.Description, logDTO.Description);
Assert.Equal(testLog.Layer.Name, logDTO.Layer.Name);
Assert.Equal(testLog.Level.Name, logDTO.Level.Name);
Assert.Equal(testLog.Status.Name, logDTO.Status.Name);
Assert.Equal(testLog.Environment.Name, logDTO.Environment.Name);
Assert.Equal(testLog.CreatedAt, logDTO.CreatedAt);
Assert.Equal(testLog.User.FullName, logDTO.User.FullName);
}
}
public async Task UpdateLogAsync(Log log)
{
if (!LogValidator.ValidateDefault(log))
{
throw new InvalidOperationException(Resources.LogValidFailString);
}
await _logsRepository.UpdateLogAsync(log);
}
public async Task <long> CreateNewLogAsync(Log log)
{
if (!LogValidator.ValidateDefault(log))
{
throw new InvalidOperationException(Resources.LogValidFailString);
}
return(await _logsRepository.AddLogAsync(log));
}
public static async Task <bool> ShowReplay(GameStats game, bool showToast)
{
if (game == null)
{
return(false);
}
if (Config.Instance.ForceLocalReplayViewer)
{
ReplayReader.LaunchReplayViewer(game.ReplayFile, false);
return(true);
}
Action <ReplayProgress> setToastStatus = null;
if (game.HasReplayFile && !game.HsReplay.Uploaded)
{
if (showToast)
{
setToastStatus = ToastManager.ShowReplayProgressToast();
}
var log = GetLogFromHdtReplay(game.ReplayFile).ToArray();
var validationResult = LogValidator.Validate(log);
if (validationResult.IsValid)
{
await LogUploader.Upload(log, null, game);
}
else
{
Log.Error("Invalid log: " + validationResult.Reason);
game.HsReplay.Unsupported = true;
}
if (DefaultDeckStats.Instance.DeckStats.Any(x => x.DeckId == game.DeckId))
{
DefaultDeckStats.Save();
}
else
{
DeckStatsList.Save();
}
}
if (game.HsReplay?.Uploaded ?? false)
{
setToastStatus?.Invoke(ReplayProgress.Complete);
Helper.TryOpenUrl(game.HsReplay?.Url);
}
else if (game.HasReplayFile)
{
setToastStatus?.Invoke(ReplayProgress.Error);
ReplayReader.LaunchReplayViewer(game.ReplayFile, true);
}
else
{
setToastStatus?.Invoke(ReplayProgress.Error);
return(false);
}
return(true);
}
public static async Task <bool> ShowReplay(GameStats game, bool showToast)
{
if (game == null)
{
return(false);
}
Action <ReplayProgress> setToastStatus = null;
if (game.HasReplayFile && !game.HsReplay.Uploaded)
{
if (showToast)
{
setToastStatus = ToastManager.ShowReplayProgressToast();
}
var log = GetLogFromHdtReplay(game.ReplayFile).ToArray();
var validationResult = LogValidator.Validate(log);
if (validationResult.IsValid)
{
await LogUploader.Upload(log, null, game);
}
else
{
Log.Error("Invalid log: " + validationResult.Reason);
game.HsReplay.Unsupported = true;
}
if (DefaultDeckStats.Instance.DeckStats.Any(x => x.DeckId == game.DeckId))
{
DefaultDeckStats.Save();
}
else
{
DeckStatsList.Save();
}
}
if (game.HsReplay?.Uploaded ?? false)
{
setToastStatus?.Invoke(ReplayProgress.Complete);
Helper.TryOpenUrl(game.HsReplay?.Url);
}
else
{
setToastStatus?.Invoke(ReplayProgress.Error);
if (game.HsReplay?.Unsupported ?? false)
{
ErrorManager.AddError("Can not load replay", "Game has no valid replay.");
}
else
{
ErrorManager.AddError("Error uploading replay", "Please try again later.");
}
return(false);
}
return(true);
}
public static async Task ShowReplay(string fileName, bool showToast)
{
if (Config.Instance.ForceLocalReplayViewer)
{
ReplayReader.LaunchReplayViewer(fileName, false);
return;
}
Action <ReplayProgress> setToastStatus = null;
var log = GetLogFromHdtReplay(fileName).ToArray();
var validationResult = LogValidator.Validate(log);
if (validationResult.IsValid)
{
if (showToast)
{
setToastStatus = ToastManager.ShowReplayProgressToast();
}
setToastStatus?.Invoke(ReplayProgress.Uploading);
var file = new FileInfo(fileName);
var hsBuild = BuildDates.GetByDate(file.LastWriteTime);
var metaData = hsBuild != null ? new GameMetaData()
{
HearthstoneBuild = hsBuild
} : null;
var gameStats = hsBuild != null ? new GameStats()
{
StartTime = file.LastWriteTime
} : null;
var success = await LogUploader.Upload(log.ToArray(), metaData, gameStats);
if (success)
{
Helper.TryOpenUrl(gameStats?.HsReplay?.Url);
}
else
{
ReplayReader.LaunchReplayViewer(fileName, true);
}
}
else
{
Log.Error("Invalid log: " + validationResult.Reason);
ReplayReader.LaunchReplayViewer(fileName, true);
}
setToastStatus?.Invoke(ReplayProgress.Complete);
}
public void Should_Return_All_Log()
{
var fakeContext = new FakeContext("GetAllLog");
fakeContext.FillWith <Log>();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var logCountIndDb = context.Log.Count();
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
Assert.Equal(logCountIndDb, service.GetAll().Count());
repository.Dispose();
}
}
public void Should_Get_Log_By_EnvironmentId(int userId, int environmentId)
{
var fakeContext = new FakeContext("ControllerGetLogById");
fakeContext.FillWith <User>();
fakeContext.FillWith <Log>();
fakeContext.FillWith <Environment>();
var auth = new UserAuthenticationTest();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LogRepository(context);
var userRepository = new UserRepository(context);
var validator = new LogValidator();
var userValidator = new UserValidator(context);
var service = new LogService(repository, validator, context);
var userService = new UserService(userRepository, userValidator);
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile <AutoMapperProfile>();;
});
var mapper = mockMapper.CreateMapper();
var controller = new LogController(service, mapper);
var user = userService.GetById(userId);
var log = service.GetByEnvironmentId(environmentId);
authServer.CreateClient();
var token = auth.GetToken(user.Email, user.Password);
var client = server.CreateClient();
client.SetBearerToken(token.access_token);
var response = client.GetAsync($"log/environment/{environmentId}").Result;
var result = response.Content.ReadAsStringAsync();
var retrLog = JsonConvert.DeserializeObject <List <Log> >(result.Result);
Assert.IsType <HttpStatusCode>(response.StatusCode);
Assert.IsType <List <Log> >(retrLog);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
foreach (var testLog in retrLog)
{
Assert.IsType <string>(testLog.Name);
Assert.IsType <string>(testLog.Description);
Assert.IsType <int>(testLog.Id);
}
}
}
public void Should_Get_Log_Properties_After_Creation()
{
var fakeContext = new FakeContext("LogGetter");
fakeContext.FillWithAll();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var logbuilder = new LogBuilder(context);
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var logTest = new Log();
logTest.Name = "Error testing";
logTest.Description = "Testing log getter and setters";
logTest.UserId = 1;
logTest.LevelId = 2;
logTest.LayerId = 2;
logTest.EnvironmentId = 2;
logTest.StatusId = 1;
logTest.CreatedAt = new DateTime(2020, 05, 21, 14, 35, 01);
service.Create(logTest);
var createdLog = (from l in service.GetAllFull()
where l.Name == "Error testing"
select l).FirstOrDefault();
Assert.Equal("Error testing", createdLog.Name);
Assert.Equal("Testing log getter and setters", createdLog.Description);
Assert.Equal(1, createdLog.UserId);
Assert.Equal(2, createdLog.LevelId);
Assert.Equal(2, createdLog.LayerId);
Assert.Equal(2, createdLog.EnvironmentId);
Assert.Equal(1, createdLog.StatusId);
Assert.Equal(new DateTime(2020, 05, 21, 14, 35, 01), createdLog.CreatedAt);
Assert.Equal("José da Silva", createdLog.User.FullName);
Assert.Equal("Warning", createdLog.Level.Name);
Assert.Equal("Frontend", createdLog.Layer.Name);
Assert.Equal("Homologação", createdLog.Environment.Name);
Assert.Equal("Arquivado", createdLog.Status.Name);
context.Dispose();
}
}
public void Should_Build_Log_Correctly(int id)
{
var fakeContext = new FakeContext("LogBuilderTest");
fakeContext.FillWith <Log>();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var build = new LogBuilder(context);
var testLog = service.GetById(id);
var builtLog = build.GetPayload(testLog);
Assert.IsType <Log>(builtLog);
Assert.NotNull(builtLog);
}
}
public void Should_Update_Existing_Log(int id)
{
var fakeContext = new FakeContext("UpdateLog");
fakeContext.FillWith <Log>();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var curretLog = service.GetById(id);
curretLog.Name = "Testing";
service.Update(curretLog);
Assert.Equal("Testing", service.GetById(id).Name);
repository.Dispose();
}
}
public void Should_Delete_Log()
{
var fakeContext = new FakeContext("DeleteLogLog");
fakeContext.FillWith <Log>();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var currentCount = context.Log.Count();
Assert.NotEqual(0, currentCount);
service.Delete(1);
Assert.NotEqual(currentCount, context.Log.Count());
repository.Dispose();
}
}
public void Should_Get_By_EnvironmentId(int id)
{
var fakeContext = new FakeContext("DeleteLogLog");
fakeContext.FillWith <Log>();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var logByEnvId = service.GetByEnvironmentId(id);
foreach (var log in logByEnvId)
{
Assert.Equal(id, log.EnvironmentId);
}
}
}
public async Task <UploadStatus> Upload(string[] logLines, UploadMetaData data)
{
var result = LogValidator.Validate(logLines);
if (!result.IsValid)
{
UploadError?.Invoke(new UploadErrorEventArgs(0, data, result.Reason));
return(new UploadStatus(new InvalidLogException(result.Reason)));
}
var log = string.Join(Environment.NewLine, logLines);
var item = new UploaderItem(log.GetHashCode());
if (_inProgress.Contains(item))
{
Log.Debug($"{item.Hash} already in progress. Waiting for it to complete...");
_inProgress.Add(item);
return(await item.Status);
}
_inProgress.Add(item);
Log.Debug($"Uploading {item.Hash}...");
UploadStatus status;
UploadInitiated?.Invoke(new UploadStatusChangedEventArgs(item.Hash, data));
try
{
status = await TryUpload(logLines, data);
}
catch (Exception ex)
{
Log.Error(ex);
status = new UploadStatus(ex);
}
Log.Debug($"{item.Hash} complete. Success={status.Success}");
UploadComplete?.Invoke(new UploadCompleteEventArgs(item.Hash, data, status));
foreach (var waiting in _inProgress.Where(x => x.Hash == item.Hash))
{
waiting.Complete(status);
}
_inProgress.RemoveAll(x => x.Hash == item.Hash);
return(status);
}
public static async Task ShowReplay(string fileName, bool showToast)
{
Action <ReplayProgress> setToastStatus = null;
var log = GetLogFromHdtReplay(fileName).ToArray();
var validationResult = LogValidator.Validate(log);
if (validationResult.IsValid)
{
if (showToast)
{
setToastStatus = ToastManager.ShowReplayProgressToast();
}
setToastStatus?.Invoke(ReplayProgress.Uploading);
var file = new FileInfo(fileName);
var hsBuild = BuildDates.GetByDate(file.LastWriteTime);
var metaData = hsBuild != null ? new GameMetaData()
{
HearthstoneBuild = hsBuild
} : null;
var gameStats = hsBuild != null ? new GameStats()
{
StartTime = file.LastWriteTime
} : null;
var success = await LogUploader.Upload(log.ToArray(), metaData, gameStats);
if (success)
{
Helper.TryOpenUrl(gameStats?.HsReplay?.Url);
setToastStatus?.Invoke(ReplayProgress.Complete);
}
else
{
ErrorManager.AddError("Error uploading replay", "Please try again later.");
setToastStatus?.Invoke(ReplayProgress.Error);
}
}
else
{
Log.Error("Invalid log: " + validationResult.Reason);
ErrorManager.AddError("Can not load replay", $"{fileName} does not contain a valid replay.");
}
}
public void Should_Get_By_Environment_and_Layer_Id(int environmentId, int layerId)
{
var fakeContext = new FakeContext("DeleteLogLog");
fakeContext.FillWith <Log>();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var logByEnvAndLayerId = service.GetByEnvironmentAndLayer(environmentId, layerId);
foreach (var log in logByEnvAndLayerId)
{
Assert.NotEqual(0, log.Id);
Assert.IsType <Log>(log);
}
}
}
public void Should_GetFullLog()
{
var fakeContext = new FakeContext("DeleteLogLog");
fakeContext.FillWith <Log>();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var logs = service.GetAllFull();
foreach (var log in logs)
{
Assert.NotEqual(0, log.Id);
}
Assert.NotEmpty(logs);
}
}
public void Should_Return_Right_Log_When_Find_By_Id(int id)
{
var fakeContext = new FakeContext("LogById");
fakeContext.FillWith <Log>();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var expected = fakeContext.GetFakeData <Log>().Find(x => x.Id == id);
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var actual = service.GetById(id);
var tryZeroId = service.GetById(0);
Assert.Null(tryZeroId);
Assert.Equal(expected, actual, new LogIdComparer());
repository.Dispose();
}
}
private async Task SaveReplays()
{
if (!_savedReplay && _game.CurrentGameStats != null)
{
_savedReplay = true;
await LogIsComplete();
var powerLog = new List <string>();
foreach (var stored in _game.StoredPowerLogs.Where(x => x.Item1 == _game.MetaData.ServerInfo.GameHandle))
{
powerLog.AddRange(stored.Item2);
}
powerLog.AddRange(_game.PowerLog);
var createGameCount = 0;
powerLog = powerLog.TakeWhile(x => !(x.Contains("CREATE_GAME") && createGameCount++ == 1)).ToList();
if (Config.Instance.RecordReplays && RecordCurrentGameMode && _game.Entities.Count > 0 && !_game.SavedReplay &&
_game.CurrentGameStats.ReplayFile == null)
{
_game.CurrentGameStats.ReplayFile = ReplayMaker.SaveToDisk(_game.CurrentGameStats, powerLog);
}
if (Config.Instance.HsReplayAutoUpload && UploadCurrentGameMode)
{
var log = powerLog.ToArray();
var validationResult = LogValidator.Validate(log);
if (validationResult.IsValid)
{
LogUploader.Upload(log, (GameMetaData)_game.MetaData.Clone(), _game.CurrentGameStats).Forget();
}
else
{
Log.Error("Invalid log: " + validationResult.Reason);
Influx.OnEndOfGameUploadError(validationResult.Reason);
}
}
}
}
public void Should_Get_By_Environment_And_Description(int environmentId, string description)
{
var fakeContext = new FakeContext("DeleteLogLog");
fakeContext.FillWith <Log>();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var logByEnvAndDescriptionId = service
.GetByEnvironmentAndDescription(environmentId, description);
foreach (var log in logByEnvAndDescriptionId)
{
Assert.Contains("tentar", log.Description);
}
Assert.NotEmpty(logByEnvAndDescriptionId);
Assert.NotNull(logByEnvAndDescriptionId);
}
}
public void Should_Get_Log_Info_Right(int id)
{
var fakeContext = new FakeContext("LogInfo");
fakeContext.FillWith <Log>();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var logbuilder = new LogBuilder(context);
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var logTest = service.GetById(id);
Assert.NotEqual(0, logTest.UserId);
Assert.NotNull(logbuilder.GetPayload(logTest));
Assert.NotEqual(0, logTest.EnvironmentId);
Assert.NotEqual(0, logTest.LayerId);
Assert.NotEqual(0, logTest.LevelId);
Assert.NotEqual(0, logTest.StatusId);
context.Dispose();
}
}
public UserController()
{
userLogic = new UserLogic();
logValidator = new LogValidator();
}
public LogService(ILogRepository repository, IMapper mapper)
{
this._repository = repository;
this._mapper = mapper;
this._validator = new LogValidator(_mapper);
}
public static void RegisterLogValidator( LogValidator handler )
{
logValidator += handler;
}
