private async Task <(StateMachineEntity, StateMachineInstanceEntity)> PutTestInstance()
{
var putDto = await PutSimpleDataSet();
var stateMachineRepository = new DummyRepository <StateMachineEntity, Guid>(_storage);
var stateMachineInstanceRepository = new DummyRepository <StateMachineInstanceEntity, Guid>(_storage);
var stateMachineEntity = await stateMachineRepository.QueryNoTrackingAsync(q =>
q.FirstOrDefaultAsyncTestable(x => x.Name == putDto.Name));
var stateMachineInstanceEntity = new StateMachineInstanceEntity()
{
Id = PrimaryKeyUtils.Generate <Guid>(),
Name = putDto.Name,
Status = StateMachineStatus.Running,
Stage = StateMachineBase.InitialStage,
InitialBlobs = putDto.InitialBlobs,
Limitation = _configuration.Limitation,
Parameters = new Dictionary <string, string>()
{
{ "Host", "http://localhost:8888" }
},
Priority = 123,
FromManagementService = _configuration.Name,
ExecutionKey = PrimaryKeyUtils.Generate <Guid>().ToString(),
StartTime = DateTime.UtcNow
};
await stateMachineInstanceRepository.AddAsync(stateMachineInstanceEntity);
await stateMachineInstanceRepository.SaveChangesAsync();
return(stateMachineEntity, stateMachineInstanceEntity);
}
public AutoCrudControllerAsyncTest()
{
_logger = new Mock <ILogger>();
_dbContext = TestUtils.MakeInMemoryDbContext <DummyDbContext>(nameof(AutoCrudControllerAsyncTest));
_repository = new DummyRepository(_dbContext);
SetupData();
}
static void Main(string[] args)
{
Console.WriteLine("PoC DB2 with Dapper");
Console.WriteLine("Querying data...");
try
{
var repo = new DummyRepository("connection_string");
IList <DummyModel> statementData = repo.GetDummyData("param1", "param2");
foreach (var item in statementData)
{
Console.WriteLine(item.Value);
}
Console.WriteLine("Worked like a charm!!!");
}
catch (System.Exception ex)
{
string folder = Environment.CurrentDirectory;
File.WriteAllText($@"{folder}\log.txt", $"{ex.Message}{ex.StackTrace}");
Console.WriteLine("Something went really bad. Visit log on root folder.");
}
Console.ReadKey();
}
public void FindAll_ReturnsExpectedData()
{
// Arrange
DummyEntity[] data =
{
new DummyEntity {
Name = "Some Name", Id = 1
},
new DummyEntity {
Name = "Other Name", Id = 2
}
};
TestHelpers.InjectData(_options, data);
using DummyContext context = new DummyContext(_options);
IDummyRepository dummyRepository = new DummyRepository(context);
// Act
IEnumerable <DummyEntity> result = dummyRepository.FindAll().ToList();
// Assert
Assert.AreEqual(2, result.Count());
Assert.AreEqual("Some Name", result.First().Name);
Assert.AreEqual("Other Name", result.Last().Name);
}
public JsonResult getData()
{
var items = DummyRepository.getItems();
//igGrid にバインドするデータをリターン
return(Json(items, JsonRequestBehavior.AllowGet));
}
public async Task ContinueRunningInstances()
{
var(_, entity) = await PutTestInstance();
var store = new StateMachineInstanceStore(
_configuration,
new DockerNodeStore(_configuration, new NotificationService()),
new DynamicCompileService());
store.Initialize(
() => new EmptyDisposable(),
_ => new DummyRepository <BlobEntity, Guid>(_storage),
_ => new DummyRepository <ActorEntity, Guid>(_storage),
_ => new DummyRepository <StateMachineEntity, Guid>(_storage),
_ => new DummyRepository <StateMachineInstanceEntity, Guid>(_storage));
var repository = new DummyRepository <StateMachineInstanceEntity, Guid>(_storage);
while (true)
{
var stateMachine = await repository.QueryNoTrackingAsync(q =>
q.FirstOrDefaultAsyncTestable(x => x.Id == entity.Id));
if (stateMachine.Status == StateMachineStatus.Failed)
{
throw new InvalidOperationException(stateMachine.Exception);
}
if (stateMachine.Status == StateMachineStatus.Succeeded)
{
Assert.Equal(1, stateMachine.ReRunTimes);
break;
}
await Task.Delay(1);
}
}
protected async Task <Guid> PutTestStateMachine(string name, string body)
{
var repository = new DummyRepository <StateMachineEntity, Guid>(_storage);
var service = new StateMachineService(repository);
return(await service.Put(new StateMachineInputDto()
{
Name = name,
Body = body
}));
}
public void Remove_DeletesDocumentFromSession()
{
Mock <IDocumentSession> documentSessionMock = new Mock <IDocumentSession>();
DummyRepository repository = new DummyRepository(documentSessionMock.Object);
DummyDocument innerDoc = new DummyDocument();
DummyEntity entity = new DummyEntity(innerDoc);
repository.Remove(entity);
documentSessionMock.Verify(x => x.Delete(innerDoc), Times.Once());
}
protected async Task <Guid> PutTestActor(string name, string body)
{
var repository = new DummyRepository <ActorEntity, Guid>(_storage);
var service = new ActorService(repository);
return(await service.Put(new ActorInputDto()
{
Name = name,
Body = body
}));
}
public void Create_movie_without_title_command_should_fail()
{
var repository = new DummyRepository <Movie>();
var handler = new MovieHandlers(repository);
handler.Awaiting(h => h.Handle(new TitleMovie
{
MovieId = Guid.NewGuid()
}, Guid.NewGuid()))
.ShouldThrow <ArgumentException>();
}
public void Create_director_without_a_name_should_fail()
{
var repository = new DummyRepository <Director>();
var handler = new DirectorHandlers(repository);
handler.Awaiting(h => h.Handle(new NameDirector
{
DirectorId = Guid.NewGuid(),
}, Guid.NewGuid()))
.ShouldThrow <ArgumentException>();
}
public void Add_SavesDocumentToSession()
{
Mock <IDocumentSession> documentSessionMock = new Mock <IDocumentSession>();
DummyRepository repository = new DummyRepository(documentSessionMock.Object);
DummyDocument innerDoc = new DummyDocument();
DummyEntity entity = new DummyEntity(innerDoc);
repository.Add(entity);
documentSessionMock.Verify(x => x.Store(innerDoc), Times.Once());
}
public void Load_LoadsDocumentFromSession()
{
Mock <IDocumentSession> documentSessionMock = new Mock <IDocumentSession>();
DummyRepository repository = new DummyRepository(documentSessionMock.Object);
DummyDocument innerDoc = new DummyDocument();
documentSessionMock.Setup(x => x.Load <DummyDocument>("testId")).Returns(innerDoc);
DummyEntity entity = repository.Load("testId");
Assert.AreEqual(innerDoc, entity.GetInnerDocument());
}
protected async Task <Guid> PutTestBlob(string remark, byte[] body)
{
var repository = new DummyRepository <BlobEntity, Guid>(_storage);
var service = new BlobService(repository);
return(await service.Put(new BlobInputDto()
{
TimeStamp = Mapper.Map <DateTime, long>(DateTime.UtcNow),
Body = Mapper.Map <byte[], string>(body),
Remark = remark
}));
}
public void FindAll_ReturnsEmptyListOnNoDummies()
{
// Arrange
using DummyContext context = new DummyContext(_options);
IDummyRepository dummyRepository = new DummyRepository(context);
// Act
IEnumerable <DummyEntity> result = dummyRepository.FindAll();
// Assert
Assert.AreEqual(0, result.Count());
}
public async Task Create_movie_on_TitleMovie_command()
{
var repository = new DummyRepository <Movie>();
var handler = new MovieHandlers(repository);
await handler.Handle(new TitleMovie
{
MovieId = Guid.NewGuid(),
Title = "Some movie"
}, Guid.NewGuid());
repository.Items.Count.Should().Be(1);
}
public async Task RunActorsAsync()
{
var(stateMachineEntity, stateMachineInstanceEntity) = await PutTestInstance();
var instance = await _store.CreateInstance(stateMachineEntity, stateMachineInstanceEntity);
var actorInfos = new List <ActorInfo>();
var startTime = DateTime.UtcNow;
for (var x = 0; x < 3; ++x)
{
actorInfos.Add(new ActorInfo()
{
Name = "CompileUserCodeActor",
StartTime = startTime,
Inputs = stateMachineInstanceEntity.InitialBlobs,
Outputs = new BlobInfo[0],
Exceptions = new string[0],
Status = ActorStatus.Running,
Stage = "CompileUserCode"
});
}
await _store.RunActors(instance, actorInfos);
var repository = new DummyRepository <StateMachineInstanceEntity, Guid>(_storage);
stateMachineInstanceEntity = await repository.QueryNoTrackingAsync(q =>
q.FirstOrDefaultAsyncTestable(x => x.Id == stateMachineInstanceEntity.Id));
Assert.Equal(3, stateMachineInstanceEntity.StartedActors.Count);
foreach (var actorInfo in stateMachineInstanceEntity.StartedActors)
{
Assert.Equal("CompileUserCodeActor", actorInfo.Name);
Assert.Equal(startTime, actorInfo.StartTime);
Assert.True(actorInfo.EndTime != null);
Assert.Equal(
JsonConvert.SerializeObject(stateMachineInstanceEntity.InitialBlobs),
JsonConvert.SerializeObject(actorInfo.Inputs));
Assert.Equal(4, actorInfo.Outputs.Count());
Assert.True(actorInfo.Outputs.Any(x => x.Name == "runner.json"));
Assert.True(actorInfo.Outputs.Any(x => x.Name == "Main.out"));
Assert.True(actorInfo.Outputs.Any(x => x.Name == "stdout.txt"));
Assert.True(actorInfo.Outputs.Any(x => x.Name == "stderr.txt"));
Assert.Equal(0, actorInfo.Exceptions.Length);
Assert.Equal(ActorStatus.Succeeded, actorInfo.Status);
Assert.Equal("CompileUserCode", actorInfo.Stage);
Assert.True(actorInfo.Tag == null);
Assert.True(actorInfo.UsedNode != null);
Assert.True(actorInfo.UsedContainer != null);
}
}
public async Task Rating_movie_50_should_pass()
{
var movieId = Guid.NewGuid();
var repository = new DummyRepository <Movie>();
await repository.Save(new Movie(movieId, "Some movie"), Guid.Empty);
var handler = new MovieHandlers(repository);
handler.Awaiting(h => h.Handle(new RateMovieByAudience
{
MovieId = movieId,
Rating = 50
}, Guid.NewGuid())).ShouldNotThrow();
}
public async Task Critcis_rating_movie_above_100_should_fail()
{
var movieId = Guid.NewGuid();
var repository = new DummyRepository <Movie>();
await repository.Save(new Movie(movieId, "Some movie"), Guid.Empty);
var handler = new MovieHandlers(repository);
handler.Awaiting(h => h.Handle(new RateMovieByCrictics
{
MovieId = movieId,
Rating = 101
}, Guid.NewGuid())).ShouldThrow <ArgumentException>();
}
public async Task Can_add_director_to_movie()
{
var movieId = Guid.NewGuid();
var repository = new DummyRepository <Movie>();
await repository.Save(new Movie(movieId, "Some movie"), Guid.Empty);
var handler = new MovieHandlers(repository);
handler.Awaiting(h => h.Handle(new AddDirectorToMovie
{
MovieId = movieId,
Director = "Jack"
}, Guid.NewGuid())).ShouldNotThrow();
}
public async Task Rating_movie_below_zero_should_fail()
{
var movieId = Guid.NewGuid();
var repository = new DummyRepository <Movie>();
await repository.Save(new Movie(movieId, "Some movie"), Guid.Empty);
var handler = new MovieHandlers(repository);
handler.Awaiting(h => h.Handle(new RateMovieByAudience
{
MovieId = movieId,
Rating = -1
}, Guid.NewGuid())).ShouldThrow <ArgumentException>();
}
public async Task Create_movie_on_TitleMovie_command()
{
var repository = new DummyRepository <Director>();
var handler = new DirectorHandlers(repository);
var command = new NameDirector
{
DirectorId = Guid.NewGuid(),
Name = "Some Guy"
};
await handler.Handle(command, Guid.NewGuid());
repository.Items.Count.Should().Be(1);
}
public async Task SetInstanceStage()
{
var(stateMachineEntity, stateMachineInstanceEntity) = await PutTestInstance();
var instance = await _store.CreateInstance(stateMachineEntity, stateMachineInstanceEntity);
await _store.SetInstanceStage(instance, StateMachineBase.FinalStage);
var repository = new DummyRepository <StateMachineInstanceEntity, Guid>(_storage);
stateMachineInstanceEntity = await repository.QueryNoTrackingAsync(q =>
q.FirstOrDefaultAsyncTestable(x => x.Id == stateMachineInstanceEntity.Id));
Assert.Equal(StateMachineBase.FinalStage, stateMachineInstanceEntity.Stage);
}
public async Task Describing_an_exiting_movie_with_an_future_year_should_fail()
{
var movieId = Guid.NewGuid();
var repository = new DummyRepository <Movie>();
await repository.Save(new Movie(movieId, "Some movie"), Guid.Empty);
var handler = new MovieHandlers(repository);
handler.Awaiting(h => h.Handle(new DescribeMovie
{
MovieId = movieId,
Synopsis = "Synopsis",
CriticsConsensus = "CriticsConsensus",
Year = DateTime.Now.Year + 1
}, Guid.NewGuid()))
.ShouldThrow <ArgumentException>();
}
public async Task Describing_an_exiting_movie_should_pass()
{
var movieId = Guid.NewGuid();
var repository = new DummyRepository <Movie>();
await repository.Save(new Movie(movieId, "Some movie"), Guid.Empty);
var handler = new MovieHandlers(repository);
await handler.Handle(new DescribeMovie
{
MovieId = movieId,
Synopsis = "Synopsis",
CriticsConsensus = "CriticsConsensus",
Year = 2014
}, Guid.NewGuid());
repository.Items.Count.Should().Be(1);
}
public async Task SetInstanceStage_ObsoleteExecutionKey()
{
var(stateMachineEntity, stateMachineInstanceEntity) = await PutTestInstance();
var instance = await _store.CreateInstance(stateMachineEntity, stateMachineInstanceEntity);
var repository = new DummyRepository <StateMachineInstanceEntity, Guid>(_storage);
stateMachineInstanceEntity.ExecutionKey = PrimaryKeyUtils.Generate <Guid>().ToString();
repository.Update(stateMachineInstanceEntity);
await repository.SaveChangesAsync();
await Assert.ThrowsAsync <StateMachineInterpretedException>(
() => _store.SetInstanceStage(instance, StateMachineBase.FinalStage));
repository.Remove(stateMachineInstanceEntity);
await repository.SaveChangesAsync();
await Assert.ThrowsAsync <StateMachineInterpretedException>(
() => _store.SetInstanceStage(instance, StateMachineBase.FinalStage));
}
public DocumentRepositoryTestsFixture()
{
DocumentClient = new Mock <IDocumentClient>();
DatabaseName = "test";
CollectionName = "stubs";
DocumentRepository = new DummyRepository(DocumentClient.Object, DatabaseName, CollectionName);
Document = new Dummy {
Id = Guid.NewGuid(),
Name = "Test"
};
DocumentWithoutId = new Dummy {
Name = "NoIdTest"
};
DocumentWithETag = new Dummy {
Id = Guid.NewGuid(),
Name = "Test",
ETag = "ETag"
};
Documents = new List <Dummy>
{
new Dummy
{
Id = Guid.NewGuid(),
Name = "TestA"
},
new Dummy
{
Id = Guid.NewGuid(),
Name = "TestB"
}
};
DocumentsQuery = Documents.AsQueryable().OrderBy(d => d.Id);
}
public HomeControllerTest()
{
User1 = new ClientViewModel {
id = 1, Name = "Pablo", Surname = "Rodriguez", DNI = "49012348S", Birthday = DateTime.Now, Country = "Spain", Email = "*****@*****.**", Tel = 630761825
};
User2 = new ClientViewModel {
id = 1, Name = "Pablo2", Surname = "Rodriguez2", DNI = "49012348T", Birthday = DateTime.Now, Country = "Spaina", Email = "*****@*****.**", Tel = 630761824
};
Clientes = new List <ClientViewModel>
{
User1,
User2
};
ClientRepository = new DummyRepository(Clientes);
uow = new UnitOfWork(ClientRepository);
controller = new HomeController(uow);
}
public JsonResult updateData()
{
var gridModel = new GridModel();
//igGrid トランザクション
var transactions =
gridModel.LoadTransactions <Item>(HttpContext.Request.Form["ig_transactions"]);
//トランザクションの情報を元にサーバー側のデータを更新
foreach (var t in transactions)
{
DummyRepository.updateItem(rowId: int.Parse(t.rowId), colName: t.col, value: t.value);
}
JsonResult result = new JsonResult();
Dictionary <string, bool> response = new Dictionary <string, bool>();
response.Add("Success", true);
result.Data = response;
//実行結果をリターン
return(result);
}
public void TestMethod1()
{
var repo = new DummyRepository();
var families = repo.GetFamilies();
Assert.Equal(2, families.Count);
foreach (var member in families)
{
Console.WriteLine(member.Name);
}
var toys = families
.SelectMany(f => f.FamilyMembers)
.SelectMany(m => m.Toys);
foreach (var toy in toys)
{
Console.WriteLine(toy.Name);
}
}
public void SetUp()
{
stockItemRepository = new DummyRepository<StockItem>();
historyRepository = new DummyRepository<StockItemHistoryBase>();
stockItemService = new StockItemService(stockItemRepository, historyRepository);
}
public void SetUp()
{
stockItemRepository = new DummyRepository<StockItem>();
handler = new ChangeStockItemsOnProductNameChangedEvent(stockItemRepository, () => now, () => user);
}
public void SetUp()
{
stockItemRepository = new DummyRepository<StockItem>();
createStockItemOnSizeCreatedEvent = new CreateStockItemOnSizeCreatedEvent(stockItemRepository, () => now, () => user);
}
public void SetUp()
{
stockItemRepository = new DummyRepository<StockItem>();
deactiveStockItemsOnSizesDeactivatedEvent = new DeactiveStockItemsOnSizesDeactivatedEvent(stockItemRepository, () => now, () => user);
}
public void SetUp()
{
sizeRepository = new DummyRepository<Size>();
handler = new ChangeInStockStatusOnStockItemInStockChanged(sizeRepository);
}
public void SetUp()
{
stockItemRepository = new DummyRepository<StockItem>();
decrementStockLevelOnOrderDispatchedEvent = new DecrementStockLevelOnOrderDispatchedEvent(stockItemRepository, () => now, () => user);
}
