public Task StartAsync_NotStarted_ShouldStart()
{
return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken =>
{
// Act.
await this.subject.StartAsync(cancellationToken);
await this.subject.StopAsync(CancellationToken.None);
// Assert.
this.subject.StubbedPreExecuteAsync.Verify(
f => f(It.IsNotIn(cancellationToken, CancellationToken.None)),
Times.Once()
);
this.subject.StubbedExecuteAsync.Verify(
f => f(It.IsNotIn(cancellationToken, CancellationToken.None)),
Times.Once()
);
this.subject.StubbedPostExecuteAsync.Verify(
f => f(CancellationToken.None),
Times.Once()
);
this.exceptionHandler.Verify(
h => h.RunAsync(It.IsAny <Type>(), It.IsAny <Exception>(), It.IsAny <CancellationToken>()),
Times.Never()
);
}));
}
public void Setup()
{
_field = new Mock <IField>();
_distanceHandler = new Mock <IDistanceHandler>();
_positionChecker = new Mock <IPositionChecker>();
_position = new Point(0, 0);
IAnimal[,] defaultAnimals = new IAnimal[2, 3];
defaultAnimals[0, 0] = new Antilope();
defaultAnimals[0, 1] = new Antilope();
defaultAnimals[0, 2] = new Lion();
defaultAnimals[1, 0] = null;
defaultAnimals[1, 1] = null;
defaultAnimals[1, 2] = new Lion();
_field.Setup(f => f.Width).Returns(3);
_field.Setup(f => f.Heigth).Returns(2);
_field.Setup(f => f.Animals).Returns(defaultAnimals);
List <Point> ExistingAnimals = new List <Point>();
ExistingAnimals.Add(new Point(0, 0));
ExistingAnimals.Add(new Point(1, 0));
ExistingAnimals.Add(new Point(2, 1));
ExistingAnimals.Add(new Point(2, 0));
_positionChecker.Setup(f => f.CheckEmpty(It.IsIn <Point>(ExistingAnimals))).Returns(false);
_positionChecker.Setup(f => f.CheckEmpty(It.IsNotIn <Point>(ExistingAnimals))).Returns(true);
_systemUnderTest = new AnimalFinder(_field.Object, _positionChecker.Object, _distanceHandler.Object);
}
public async Task FixObviouslyWrongEstimationsAsync()
{
var mockRpc = CreateAndConfigureRpcClient(hasPeersInfo: true);
var any = EstimateSmartFeeMode.Conservative;
mockRpc.Setup(rpc => rpc.GetMempoolInfoAsync()).ReturnsAsync(
new MemPoolInfo
{
MemPoolMinFee = 0.00001000, // 1 s/b (default value)
Histogram = MempoolInfoGenerator.FeeRanges.Select((x, i) => new FeeRateGroup
{
Count = (uint)(200 * (i + 1)),
Sizes = (uint)(40 * 100 * (i + 1)),
From = new FeeRate((decimal)x.from),
To = new FeeRate((decimal)x.to),
Fees = Money.Zero,
Group = x.from
}).ToArray()
});
mockRpc.Setup(rpc => rpc.EstimateSmartFeeAsync(2, any)).ReturnsAsync(FeeRateResponse(2, 3_500m));
mockRpc.Setup(rpc => rpc.EstimateSmartFeeAsync(3, any)).ReturnsAsync(FeeRateResponse(3, 500m));
mockRpc.Setup(rpc => rpc.EstimateSmartFeeAsync(6, any)).ReturnsAsync(FeeRateResponse(6, 10m));
mockRpc.Setup(rpc => rpc.EstimateSmartFeeAsync(18, any)).ReturnsAsync(FeeRateResponse(18, 5m));
mockRpc.Setup(rpc => rpc.EstimateSmartFeeAsync(36, any)).ReturnsAsync(FeeRateResponse(36, 5m));
mockRpc.Setup(rpc => rpc.EstimateSmartFeeAsync(1008, any)).ReturnsAsync(FeeRateResponse(1008, 1m));
mockRpc.Setup(rpc => rpc.EstimateSmartFeeAsync(It.IsNotIn <int>(2, 3, 5, 6, 8, 11, 13, 15, 1008), any)).ThrowsAsync(new NoEstimationException(0));
var allFee = await mockRpc.Object.EstimateAllFeeAsync(EstimateSmartFeeMode.Conservative);
Assert.Equal(3_500, allFee.Estimations[2]);
Assert.True(allFee.Estimations[3] > 500);
Assert.True(allFee.Estimations[1008] > 1);
}
public async Task StopAsync_AlreadyRunning_ShouldCancelWaitForNewBlock()
{
// Arrange.
this.handler.GetBlockHintAsync(Arg.Any <CancellationToken>()).Returns(1);
this.rpc.Setup(r => r.GetBlockAsync(1, It.IsAny <CancellationToken>()))
.ThrowsAsync(new RPCException(
RPCErrorCode.RPC_INVALID_PARAMETER,
"Block height out of range",
null
));
var background = await this.subject.StartAsync(this.handler, CancellationToken.None);
// Act.
await this.subject.StopAsync(CancellationToken.None);
// Assert.
_ = this.handler.Received(1).GetBlockHintAsync(Arg.Any <CancellationToken>());
this.rpc.Verify(r => r.GetBlockAsync(1, It.IsNotIn(CancellationToken.None)), Times.Once());
_ = this.handler.Received(0).ProcessBlockAsync(Arg.Any <Block>(), Arg.Any <int>(), Arg.Any <CancellationToken>());
this.subject.IsRunning.Should().BeFalse();
background.IsCanceled.Should().BeTrue();
}
public async Task StopAsync_AlreadyRunning_ShouldCancelProcessBlockAsync()
{
var block = Block.CreateBlock(ZcoinNetworks.Instance.Regtest);
// Arrange.
this.handler.GetBlockHintAsync(Arg.Any <CancellationToken>()).Returns(0);
this.rpc.Setup(r => r.GetBlockAsync(0, It.IsAny <CancellationToken>())).ReturnsAsync(block);
this.handler.When(h => h.ProcessBlockAsync(block, 0, Arg.Any <CancellationToken>())).Do(call =>
{
var token = call.ArgAt <CancellationToken>(2);
token.WaitHandle.WaitOne();
token.ThrowIfCancellationRequested();
});
var background = await this.subject.StartAsync(this.handler, CancellationToken.None);
// Act.
await this.subject.StopAsync(CancellationToken.None);
// Assert.
_ = this.handler.Received(1).GetBlockHintAsync(Arg.Any <CancellationToken>());
this.rpc.Verify(r => r.GetBlockAsync(0, It.IsNotIn(CancellationToken.None)), Times.Once());
_ = this.handler.Received(1).ProcessBlockAsync(block, 0, Arg.Any <CancellationToken>());
this.subject.IsRunning.Should().BeFalse();
background.IsCanceled.Should().BeTrue();
}
public async Task Test_that_read_block_command_is_processed()
{
//ARRANGE
var countdown = new CountdownEvent(2);
Mock <IBlockReader> blockReader = null;
var blockEventsHandlerMock = BlockEventsHandlerCreateMock((intName, evt, headers, messagePublisher) =>
{
});
var(client, apiFactory, testServer) = PrepareClient <AppSettings>(
serverOptions =>
{
CreateMocks(
out blockReader,
out var blockProvider);
serverOptions.IntegrationName = _integrationName;
serverOptions.UseTransferAmountTransactionsModel();
blockReader
.Setup(x => x.ReadBlockAsync(2, It.IsAny <IBlockListener>()))
.Returns(Task.CompletedTask)
.Callback(() => { countdown.Signal(); });
blockReader
.Setup(x => x.ReadBlockAsync(1, It.IsAny <IBlockListener>()))
.Returns(Task.CompletedTask)
.Callback(() => { countdown.Signal(); });
blockProvider.Setup(x => x.GetLastAsync()).ReturnsAsync(new LastIrreversibleBlockUpdatedEvent(1, "1"));
ConfigureFactories(serverOptions, blockReader, blockProvider);
},
clientOptions =>
{
clientOptions.BlockEventsHandlerFactory =
(context) => blockEventsHandlerMock.Object;
clientOptions.RabbitVhost = _rabbitMqSettings.Vhost;
clientOptions.RabbitMqConnString = _rabbitMqSettings.GetConnectionString();
clientOptions.AddIntegration(_integrationName);
});
//ACT
using (testServer)
using (client)
{
client.Initialize();
var apiBlocksReader = apiFactory.Create(_integrationName);
await apiBlocksReader.SendAsync(new ReadBlockCommand(1), null);
await apiBlocksReader.SendAsync(new ReadBlockCommand(2), null);
countdown.Wait(Waiting.Timeout);
}
//ASSERT
blockReader.Verify(x => x.ReadBlockAsync(1, It.IsNotNull <IBlockListener>()), Times.AtLeastOnce);
blockReader.Verify(x => x.ReadBlockAsync(2, It.IsNotNull <IBlockListener>()), Times.AtLeastOnce);
blockReader.Verify(x => x.ReadBlockAsync(It.IsNotIn(1, 2), It.IsNotNull <IBlockListener>()), Times.Never);
}
public async Task StartAsync_GetBlockHintAsyncReturnTooHeight_ShouldWaitForNewBlockNotification()
{
// Arrange.
var block = Block.CreateBlock(ZcoinNetworks.Instance.Regtest);
this.handler.GetBlockHintAsync(Arg.Any <CancellationToken>()).Returns(1);
this.rpc.SetupSequence(r => r.GetBlockAsync(1, It.IsAny <CancellationToken>()))
.ThrowsAsync(new RPCException(
RPCErrorCode.RPC_INVALID_PARAMETER,
"Block height out of range",
null
))
.ReturnsAsync(block);
// Act.
var background = await this.subject.StartAsync(this.handler, CancellationToken.None);
await Task.Delay(500);
this.handler.ProcessBlockAsync(block, 1, Arg.Any <CancellationToken>()).Returns(Task.FromException <int>(new OperationCanceledException()));
this.publisher.SendMoreFrame("hashblock").SendMoreFrame(uint256.One.ToBytes()).SendFrame(BitConverter.GetBytes(0));
await Task.WhenAny(background);
// Assert.
_ = this.handler.Received(1).GetBlockHintAsync(Arg.Any <CancellationToken>());
this.rpc.Verify(
r => r.GetBlockAsync(1, It.IsNotIn(CancellationToken.None)),
Times.Exactly(2)
);
_ = this.handler.Received(1).ProcessBlockAsync(block, 1, Arg.Any <CancellationToken>());
}
public void PassingUnAuthorisableGroupIDToControllerThrowsUnauthorizedResult()
{
//Mock the repository
var repository =
new Mock <IStagingRepository <MassTerminationModelSerialized> >(MockBehavior.Strict);
//Mock data factory
var dataFactory =
new Mock <IDataFactory>(MockBehavior.Strict);
dataFactory.Setup(d => d.GetMassTerminateRepository()).Returns(repository.Object);
//Mapping factory
IMappingFactory mapFactory = new MappingFactory();
//Mock Auth
var authorization = new Mock <IAuthorizationProvider>(MockBehavior.Strict);
authorization.Setup(s => s.IsAuthorized(It.IsNotIn <string>(new List <string>()
{
"426"
}))).Returns(false);
var controller = new MassTerminateController(dataFactory.Object, authorization.Object, mapFactory);
Task <IHttpActionResult> actionResult = controller.SetDataAsync("123", models);
Assert.IsInstanceOfType(actionResult.Result, typeof(UnauthorizedResult));
}
public void Arrange()
{
OrgQueryRepository = new Mock <IOrganisationQueryRepository>();
ContactQueryRepository = new Mock <IContactQueryRepository>();
ContactQueryRepository.Setup(r => r.GetBySignInId(It.IsNotIn(Guid.Empty)))
.Returns(Task.FromResult(new Contact()
{
Id = It.IsAny <Guid>(), Status = ContactStatus.Live,
OrganisationId = It.IsAny <Guid>(), Username = "******", Email = "*****@*****.**"
}));
ContactQueryRepository.Setup(r => r.GetBySignInId(Guid.Empty))
.Returns(Task.FromResult(new Contact()
{
Id = Guid.Empty, Status = ContactStatus.InvitePending,
OrganisationId = It.IsAny <Guid>(), Username = "******", Email = "*****@*****.**"
}));
OrgQueryRepository.Setup(r => r.Get(It.IsAny <Guid>())).ReturnsAsync(new Organisation
{
EndPointAssessorName = "SomeName",
EndPointAssessorUkprn = 12345,
Id = It.IsAny <Guid>(),
Status = OrganisationStatus.New
});
ContactRepository = new Mock <IContactRepository>();
ContactRepository.Setup(x => x.UpdateUserName(It.IsAny <Guid>(), It.IsAny <string>())).Returns(Task.FromResult(default(object)));
RegisterRepository = new Mock <IRegisterRepository>();
RegisterRepository.Setup(m => m.UpdateEpaOrganisationPrimaryContact(It.IsAny <Guid>(), It.IsAny <string>())).Returns(Task.FromResult(default(object)));
Handler = new LoginHandler(new Mock <ILogger <LoginHandler> >().Object,
OrgQueryRepository.Object, ContactQueryRepository.Object, ContactRepository.Object, RegisterRepository.Object);
}
public void Get_Team_NotInTeam()
{
var spelerMock = new Mock <ISpelerRepository>();
var teamMock = new Mock <ITeamRepository>();
//Arrange
var id = 2;
spelerMock.Setup(s => s.GetSpeler(id)).Returns(new Speler()
{
Id = 2,
AssignedTeam = null,
DeviceId = "1",
});
spelerMock.Setup(s => s.GetSpeler(It.IsNotIn(2))).Returns((Speler)null);
teamMock.Setup(t => t.GetTeam(1)).Returns(_fakeTeamRepo.GetTeam(1));
teamMock.Setup(t => t.GetTeam(2)).Returns(_fakeTeamRepo.GetTeam(2));
teamMock.Setup(t => t.GetTeam(3)).Returns(_fakeTeamRepo.GetTeam(3));
teamMock.Setup(t => t.GetTeam(It.IsNotIn(1, 2, 3))).Returns((Team)null);
var speler = new SpelerService(spelerMock.Object, teamMock.Object);
var sid = 2;
// Act
Team result = speler.GetTeamFromSpeler(sid);
// Assert
Assert.Null(result);
}
public void TestNewTopicCommandSuccess()
{
string projectIdParam = null;
string details = null;
_dataSourceMock.Setup(ds => ds.NewTopicAsync(It.IsAny <string>())).Returns(Task.FromResult(s_topic));
_objectUnderTest.Initialize(_contextMock.Object);
_objectUnderTest.NewTopicUserPrompt = projectId =>
{
projectIdParam = projectId;
return(MockTopicFullName);
};
UserPromptWindow.PromptUserFunction = options =>
{
details = options.ErrorDetails;
return(true);
};
_objectUnderTest.OnNewTopicCommand();
Assert.AreEqual(MockProjectId, projectIdParam);
Assert.IsNull(details);
Assert.AreEqual(1, _objectUnderTest.RefreshHitCount);
_dataSourceMock.Verify(ds => ds.NewTopicAsync(MockTopicFullName), Times.Once);
_dataSourceMock.Verify(ds => ds.NewTopicAsync(It.IsNotIn(MockTopicFullName)), Times.Never);
}
public TestsFixture()
{
// Do "global" initialization here; Only called once.
MockPinService = new Mock <IPinService>();
MockPinService.Setup(x => x.VerifyPin(It.IsAny <long>(), 1234)).Returns(true);
MockPinService.Setup(x => x.VerifyPin(It.IsAny <long>(), It.IsNotIn(1234))).Returns(false);
}
public CourseLibraryServiceTest()
{
mockAuthor = new Mock <Author>();
mockCourseLibraryService.Setup(m => m.AddAuthor(It.IsAny <Author>())).ReturnsAsync(new SuccessOperationResult <Author> {
Result = mockAuthor.Object, Code = ConstOperationCodes.AUTHOR_CREATED
});
mockCourseLibraryService.Setup(m => m.GetAuthor(It.IsNotIn(Guid.Empty), false)).ReturnsAsync(new SuccessOperationResult <Author>
{
Code = ConstOperationCodes.AUTHOR_FOUND,
Result = mockAuthor.Object
});
mockCourseLibraryService.Setup(m => m.GetAuthor(It.Is <Guid>(g => g.Equals(Guid.Empty)), false)).ReturnsAsync(
new FailedOperationResult <Author>
{
Code = ConstOperationCodes.AUTHOR_NOT_FOUND,
}
);
mockCourseLibraryService.Setup(m => m.AddAuthor(It.Is <Author>(a => a.FirstName == "exsits"))).ReturnsAsync(
new FailedOperationResult <Author>
{
Code = ConstOperationCodes.AUTHOR_NAME_ALREADY_EXISTS,
}
);
}
public static void SetupFor(this Mock <IRequesterSecurity> requesterSecurity, Requester requester)
{
requesterSecurity.AssertNotNull("requesterSecurity");
requester.AssertNotNull("requester");
if (requester.Equals(Requester.Unauthenticated))
{
throw new ArgumentException("Requester must be authorized.", "requester");
}
requesterSecurity.Setup(v => v.AuthenticateAsync(Requester.Unauthenticated))
.Throws(new UnauthorizedException());
requesterSecurity.Setup(v => v.AuthenticateAsync(requester))
.ReturnsAsync(requester.UserId);
requesterSecurity.Setup(v => v.AuthenticateAsAsync(Requester.Unauthenticated, It.IsAny <UserId>()))
.Throws(new UnauthorizedException());
requesterSecurity.Setup(v => v.AuthenticateAsAsync(requester, It.IsNotIn(requester.UserId)))
.Throws(new UnauthorizedException());
requesterSecurity.Setup(v => v.AuthenticateAsAsync(requester, requester.UserId))
.ReturnsAsync(requester.UserId);
}
public void SetActive_Puzzel_ExistingTeam()
{
var fakeTeam = GameDBFake.teams.ToList();;
var _LocalfakeTeamRepo = new TeamRepositoryFake();
var spelerMock = new Mock <ISpelerRepository>();
var sessieMock = new Mock <ISessionRepository>();
var teamMock = new Mock <ITeamRepository>();
var puzzelMock = new Mock <IPuzzelRepository>();
teamMock.Setup(t => t.GetTeams()).Returns(fakeTeam);
teamMock.Setup(t => t.GetTeam(It.IsIn(1, 2))).Returns((int i) => fakeTeam[0]);
teamMock.Setup(t => t.SetActivePuzzel(It.IsIn(1, 2), It.IsAny <int>())).Callback <int, int>((a, b) => fakeTeam[0].ActivePuzzel = 0);
teamMock.Setup(t => t.GetTeam(It.IsNotIn(1, 2))).Returns((Team)null);
puzzelMock.Setup(p => p.GetPuzzel(It.IsAny <int>())).Returns(new Puzzel());
var team = new TeamService(teamMock.Object,
spelerMock.Object,
sessieMock.Object,
puzzelMock.Object);
//Arrange
var teamId = 1;
// Act
var result = team.SetActivePuzzel(teamId, false);
var resultId = team.ActivePuzzelID(teamId);
// Assert
Assert.IsType <Puzzel>(result);
Assert.NotEqual(-1, resultId);
}
public void TestCaption()
{
pdfBuilder.AppendText("Not be in same paragraph as image", TextStyle.Normal);
inline.IsImage = true;
string altText = "alt";
inline.AppendChild(new LiteralInline(altText));
Mock <PdfBuilder> builder = new Mock <PdfBuilder>(document, PdfOptions.Default);
builder.Setup(b => b.AppendText(altText, It.IsAny <TextStyle>())).Callback <string, TextStyle>((_, style) => Assert.AreEqual(TextStyle.Normal, style)).CallBase();
builder.Setup(b => b.AppendText(It.IsNotIn(altText), It.IsAny <TextStyle>())).Callback <string, TextStyle>((_, style) => Assert.AreEqual(TextStyle.Strong, style)).CallBase();
using (Image image = new Bitmap(4, 4))
{
Mock <LinkInlineRenderer> renderer = new Mock <LinkInlineRenderer>(null);
renderer.CallBase = true;
renderer.Setup(r => r.GetImage(It.IsAny <string>())).Returns(image);
renderer.Object.Write(builder.Object, inline);
}
Assert.AreEqual(2, TestContext.CurrentContext.AssertCount, "Plumbing is broken");
Assert.AreEqual(2, document.LastSection.Elements.Count);
Paragraph caption = (Paragraph)document.LastSection.Elements[1];
Assert.AreEqual(2, caption.Elements.Count);
FormattedText figureNumber = (FormattedText)caption.Elements[0];
FormattedText formattedAltText = (FormattedText)caption.Elements[1];
Text figureText = (Text)figureNumber.Elements[0];
Text insertedAltText = (Text)formattedAltText.Elements[0];
Assert.AreEqual("Figure 1: ", figureText.Content);
Assert.AreEqual(altText, insertedAltText.Content);
}
public void SetActive_Puzzel_NotexistingTeam()
{
var _LocalfakeTeamRepo = new TeamRepositoryFake();
var spelerMock = new Mock <ISpelerRepository>();
var sessieMock = new Mock <ISessionRepository>();
var teamMock = new Mock <ITeamRepository>();
var puzzelMock = new Mock <IPuzzelRepository>();
teamMock.Setup(t => t.GetTeams()).Returns(_LocalfakeTeamRepo.GetTeams());
teamMock.Setup(t => t.GetTeam(It.IsIn(1, 2))).Returns((int i) => _LocalfakeTeamRepo.GetTeam(i));
teamMock.Setup(t => t.SetActivePuzzel(It.IsIn(1, 2), It.IsAny <int>())).Callback <int, int>((a, b) => _LocalfakeTeamRepo.SetActivePuzzel(a, b));
teamMock.Setup(t => t.GetTeam(It.IsNotIn(1, 2))).Returns((Team)null);
puzzelMock.Setup(p => p.GetPuzzel(It.IsAny <int>())).Returns(new Puzzel());
var team = new TeamService(teamMock.Object,
spelerMock.Object,
sessieMock.Object,
puzzelMock.Object);
//Arrange
var teamId = 9999;
// Act
var result = team.SetActivePuzzel(teamId, false);
var resultId = team.ActivePuzzelID(teamId);
// Assert
Assert.Equal(-1, resultId);
Assert.Null(result);
}
public void TestPickBestOccurrence()
{
const int occurrenceCount = 10;
const int groupingsPerOccurrence = 5;
const int individualsPerGrouping = 2;
// build several meaningless occurrences to for the mock generator to return
var occurrences = Enumerable
.Range(0, occurrenceCount)
.Select(_ => new Occurrence(DateTimeOffset.UtcNow,
Enumerable.Range(0, groupingsPerOccurrence)
.Select(__ => Enumerable.Range(0, individualsPerGrouping)
.Select(___ => Guid.NewGuid().ToString())
.ToList()).ToList())).ToList();
// arbitrarily pick one to be the expected best occurrence
var expectedOccurrence = occurrences[3];
var generator = new Mock <IOccurrenceGenerator>(MockBehavior.Strict);
generator.Setup(x => x.EnumerateOccurrences()).Returns(occurrences);
// build a mock IPairingScorer that gives high scores to expectedOccurrence
var scorer = new Mock <IPairingScorer>(MockBehavior.Strict);
scorer.Setup(x => x.ScorePairing(It.IsIn(expectedOccurrence.Groupings.SelectMany(i => i)), It.IsAny <string>()))
.Returns(50d);
scorer.Setup(x => x.ScorePairing(It.IsNotIn(expectedOccurrence.Groupings.SelectMany(i => i)), It.IsAny <string>()))
.Returns(1d);
var picker = new OccurrencePicker(generator.Object, scorer.Object);
var actualOccurrence = picker.PickBestOccurrence();
Assert.That(actualOccurrence, Is.EqualTo(expectedOccurrence), "The correct occurrence should be selected");
}
public void SetUp()
{
this.logger = new ActionLog();
GlobalConstants.ActionLog = this.logger;
this.target = new CombatEngine(Mock.Of <IRollable>(
roller => roller.RollSuccesses(
It.IsAny <int>(),
It.IsIn <int>(7)) == 1 &&
roller.RollSuccesses(
It.IsAny <int>(),
It.IsNotIn(7)) == 2));
this.statisticHandler = new EntityStatisticHandler();
this.skillHandler = new EntitySkillHandler();
this.derivedValueHandler = new DerivedValueHandler(this.statisticHandler, this.skillHandler);
this.abilityHandler = new AbilityHandler();
this.materialHandler = new MaterialHandler();
this.objectIconHandler = new ObjectIconHandler(new RNG());
this.itemHandler = new LiveItemHandler(new RNG());
GlobalConstants.GameManager = Mock.Of <IGameManager>(
manager => manager.ItemHandler == this.itemHandler &&
manager.ObjectIconHandler == this.objectIconHandler);
this.needHandler = new NeedHandler();
}
public SubscriptionService GetService()
{
MockAddCommand.Setup(m => m.Add(NewSubscription.FirstName,
NewSubscription.LastName,
NewSubscription.EmailAddress,
It.IsAny <Func <Subscription, Task <Subscription> > >()))
.Callback <string, string, string, Func <Subscription, Task <Subscription> > >((f, l, e, func) => Assert.NotNull(func(NewSubscription).Result))
.ReturnsAsync(NewSubscription);
MockAddCommand.Setup(m => m.Add(FailedSubscription.FirstName,
FailedSubscription.LastName,
FailedSubscription.EmailAddress,
It.IsAny <Func <Subscription, Task <Subscription> > >()))
.Callback <string, string, string, Func <Subscription, Task <Subscription> > >(async(f, l, e, func) => await Assert.ThrowsAsync <MessagingException>(async() => await func(FailedSubscription)))
.ReturnsAsync(null);
MockUpdateCommand.Setup(m => m.Update(It.Is <Subscription>(s => s.EmailAddress == NewSubscription.EmailAddress), It.IsAny <Func <Subscription, IDbConnection, IDbTransaction, Task> >()))
.Callback <Subscription, Func <Subscription, Task> >(async(s, t) => await t(s))
.Returns(Task.CompletedTask);
MockOfflineProcessing.Setup(m => m.NotifySubscriber(It.IsNotIn(NewSubscription.Id)))
.Throws(new ServerBusyException("message"));
MockOfflineProcessing.Setup(m => m.ConfirmationReceived(It.IsNotIn(NewSubscription)))
.Throws(new ServerBusyException("message"));
return(new SubscriptionService(MockAddCommand.Object, MockUpdateCommand.Object, MockOfflineProcessing.Object));
}
public async Task StartAsync_ProcessBlockAsyncReturnValidHeight_ShouldRetrieveThatBlock()
{
// Arrange.
var block1 = Block.CreateBlock(ZcoinNetworks.Instance.Regtest);
block1.Header.Nonce = 1;
block1.Header.PrecomputeHash(invalidateExisting: true, lazily: false);
var block2 = Block.CreateBlock(ZcoinNetworks.Instance.Regtest);
block2.Header.Nonce = 2;
block2.Header.PrecomputeHash(invalidateExisting: true, lazily: false);
this.handler.GetBlockHintAsync(Arg.Any <CancellationToken>()).Returns(0);
this.rpc.Setup(r => r.GetBlockAsync(0, It.IsAny <CancellationToken>())).ReturnsAsync(block1);
this.handler.ProcessBlockAsync(block1, 0, Arg.Any <CancellationToken>()).Returns(1);
this.rpc.Setup(r => r.GetBlockAsync(1, It.IsAny <CancellationToken>())).ReturnsAsync(block2);
this.handler.ProcessBlockAsync(block2, 1, Arg.Any <CancellationToken>()).Returns(Task.FromException <int>(new OperationCanceledException()));
// Act.
var background = await this.subject.StartAsync(this.handler, CancellationToken.None);
await Task.WhenAny(background);
// Assert.
_ = this.handler.Received(1).GetBlockHintAsync(Arg.Any <CancellationToken>());
this.rpc.Verify(r => r.GetBlockAsync(0, It.IsNotIn(CancellationToken.None)), Times.Once());
_ = this.handler.Received(1).ProcessBlockAsync(block1, 0, Arg.Any <CancellationToken>());
this.rpc.Verify(r => r.GetBlockAsync(1, It.IsNotIn(CancellationToken.None)), Times.Once());
_ = this.handler.Received(1).ProcessBlockAsync(block2, 1, Arg.Any <CancellationToken>());
}
public void SelectFormatter_WithNoMatchingAcceptHeadersAndRequestContentType_PicksFormatterBasedOnObjectType
(string acceptHeader)
{
// For no accept headers,
// can write is called twice once for the request Content-Type and once for the type match pass.
// For each additional accept header, it is called once.
// Arrange
var acceptHeaderCollection = string.IsNullOrEmpty(acceptHeader) ?
null : MediaTypeHeaderValue.ParseList(new[] { acceptHeader }).ToArray();
var stream = new MemoryStream();
var httpResponse = new Mock <HttpResponse>();
httpResponse.SetupProperty <string>(o => o.ContentType);
httpResponse.SetupGet(r => r.Body).Returns(stream);
var actionContext = CreateMockActionContext(httpResponse.Object,
requestAcceptHeader: acceptHeader,
requestContentType: "application/xml");
var input = "testInput";
var result = new ObjectResult(input);
var mockCountingFormatter = new Mock <IOutputFormatter>();
var context = new OutputFormatterContext()
{
HttpContext = actionContext.HttpContext,
Object = input,
DeclaredType = typeof(string)
};
var mockCountingSupportedContentType = MediaTypeHeaderValue.Parse("application/text");
mockCountingFormatter.Setup(o => o.CanWriteResult(context,
It.Is <MediaTypeHeaderValue>(mth => mth == null)))
.Returns(true);
mockCountingFormatter.Setup(o => o.CanWriteResult(context, mockCountingSupportedContentType))
.Returns(true);
// Set more than one formatters. The test output formatter throws on write.
result.Formatters = new List <IOutputFormatter>
{
new CannotWriteFormatter(),
mockCountingFormatter.Object,
};
// Act
var formatter = result.SelectFormatter(context, result.Formatters);
// Assert
Assert.Equal(mockCountingFormatter.Object, formatter);
mockCountingFormatter.Verify(v => v.CanWriteResult(context, null), Times.Once());
// CanWriteResult is invoked for the following cases:
// 1. For each accept header present
// 2. Request Content-Type
// 3. Type based match
var callCount = (acceptHeaderCollection == null ? 0 : acceptHeaderCollection.Count()) + 2;
mockCountingFormatter.Verify(v => v.CanWriteResult(context,
It.IsNotIn <MediaTypeHeaderValue>(mockCountingSupportedContentType)),
Times.Exactly(callCount));
}
public async Task StopAsync_AlreadyRunning_ShouldCancelGetBlockAsync()
{
// Arrange.
this.handler.GetBlockHintAsync(Arg.Any <CancellationToken>()).Returns(0);
this.rpc.Setup(r => r.GetBlockAsync(0, It.IsAny <CancellationToken>()))
.Callback <int, CancellationToken>((h, c) =>
{
c.WaitHandle.WaitOne();
c.ThrowIfCancellationRequested();
});
var background = await this.subject.StartAsync(this.handler, CancellationToken.None);
// Act.
await this.subject.StopAsync(CancellationToken.None);
// Assert.
_ = this.handler.Received(1).GetBlockHintAsync(Arg.Any <CancellationToken>());
this.rpc.Verify(r => r.GetBlockAsync(0, It.IsNotIn(CancellationToken.None)), Times.Once());
_ = this.handler.Received(0).ProcessBlockAsync(Arg.Any <Block>(), Arg.Any <int>(), Arg.Any <CancellationToken>());
this.subject.IsRunning.Should().BeFalse();
background.IsCanceled.Should().BeTrue();
}
public void ShouldRemoveUserInMemory()
{
var user = new User()
{
Email = "*****@*****.**",
Guid = System.Guid.NewGuid().ToString(),
HashedPassword = "******",
Name = "name",
Role = "admin",
Surname = "dksk"
};
var mockSet = new MockDbSet <User>();
var mockContext = new Mock <WorkSiteDbContext>();
mockContext.Setup(c => c.Set <User>()).Returns(mockSet.Object);
using (var uow = new WorkSiteUow(mockContext.Object))
{
uow.Users.Create(user);
uow.Save();
uow.Users.Delete(user.Guid);
uow.Save();
}
mockSet.Verify(u => u.Remove(It.IsNotIn(user)), Times.Never);
}
private IPolysurfaceVertex MockVertex(int index)
{
if (!_mockVertices.ContainsKey(index))
{
var answer = new Mock <IPolysurfaceVertex>();
_mockVertices.Add(index, answer.Object);
var edges = new List <IPolysurfaceEdge>
{
MockEdge(index),
MockEdge((index + 1) % _numIndices)
};
answer.Setup(v => v.Edges).Returns(edges);
answer.Setup(v => v.Point).Returns(MockVertexPoint(index));
answer.Setup(v => v.Order).Returns(index);
answer.Setup(v => v.Equals(answer.Object)).Returns(true);
answer.Setup(v => v.Equals(It.IsNotIn(answer.Object))).Returns(false);
answer.Setup(v => v.GetHashCode()).Returns(index);
}
return(_mockVertices[index]);
}
public void ExistingSpeler_Join_NotExistingTeam()
{
var spelerMock = new Mock <ISpelerRepository>();
var sessieMock = new Mock <ISessionRepository>();
var teamMock = new Mock <ITeamRepository>();
var puzzelMock = new Mock <IPuzzelRepository>();
teamMock.Setup(t => t.GetTeams()).Returns(_fakeTeamRepo.GetTeams());
teamMock.Setup(t => t.GetTeam(1)).Returns(_fakeTeamRepo.GetTeam(1));
teamMock.Setup(t => t.GetTeam(It.IsNotIn(1))).Returns((Team)null);
sessieMock.Setup(s => s.GetSessie(1)).Returns(_fakeSessieRepo.GetSessie(1));
spelerMock.Setup(s => s.GetSpeler(It.IsIn(1, 2, 3, 4, 5))).Returns((int i) => _fakeSpelerRepo.GetSpeler(i));
spelerMock.Setup(s => s.GetSpeler(It.IsNotIn(1, 2, 3, 4, 5))).Returns((Speler)null);
var team = new TeamService(teamMock.Object,
spelerMock.Object,
sessieMock.Object,
puzzelMock.Object);
//Arrange
var teamId = 9999;
var spelerId = 2;
// Act
bool result = team.SpelerJoin(spelerId, teamId);
// Assert
Assert.False(result);
}
private void SetupSearchResultMock()
{
var facetGroupMock = new Mock <ISearchFacetGroup>();
facetGroupMock.Setup(x => x.Name).Returns("FacetGroupName");
facetGroupMock.Setup(x => x.FieldName).Returns("FacetGroupFieldName");
_facet = new Facet(facetGroupMock.Object, "FacetKey", "FacetName", 10);
var facetList = new ISearchFacet[] { _facet };
facetGroupMock.Setup(x => x.Facets).Returns(() => facetList);
var searchDocumentMock = new Mock <ISearchDocument>();
searchDocumentMock.Setup(x => x["displayname"])
.Returns(() => new SearchField("displayname", "DisplayName"));
searchDocumentMock.Setup(x => x["image_url"])
.Returns(() => new SearchField("image_url", "/image.jpg")); // Tests will ensures that hostname gets removed
searchDocumentMock.Setup(x => x["content_link"])
.Returns(() => new SearchField("content_link", "1"));
searchDocumentMock.Setup(x => x[It.IsNotIn(new[] { "displayname", "image_url", "content_link" })])
.Returns(() => new SearchField("name", ConvertToPrefixCodedLong(1m)));
searchDocumentMock.Setup(x => x["brand"]).Returns(() => new SearchField("brand", "Brand"));
searchDocumentMock.Setup(x => x["code"]).Returns(() => new SearchField("code", "Code"));
_searchResultsMock = new Mock <ISearchResults>();
_searchResultsMock.Setup(x => x.FacetGroups).Returns(() => new[] { facetGroupMock.Object });
_searchResultsMock.Setup(x => x.Documents)
.Returns(() => new SearchDocuments {
searchDocumentMock.Object
});
}
public void GetActive_Puzzel_existingTeam()
{
var _LocalfakeTeamRepo = new TeamRepositoryFake();
var spelerMock = new Mock <ISpelerRepository>();
var sessieMock = new Mock <ISessionRepository>();
var teamMock = new Mock <ITeamRepository>();
var puzzelMock = new Mock <IPuzzelRepository>();
teamMock.Setup(t => t.GetTeams()).Returns(_LocalfakeTeamRepo.GetTeams());
teamMock.Setup(t => t.GetTeam(It.IsIn(1, 2))).Returns((int id) => { return(GameDBFake.teams.Where(g => g.Id == id).FirstOrDefault()); });
teamMock.Setup(t => t.GetTeam(It.IsNotIn(1, 2))).Returns((Team)null);
teamMock.Setup(t => t.GetActivePuzzel(2)).Returns((int id) => { return(GameDBFake.teams.Where(g => g.Id == id).FirstOrDefault().ActivePuzzel); });
teamMock.Setup(t => t.GetActivePuzzel(1)).Returns((int id) => { return(-1); });
puzzelMock.Setup(p => p.GetPuzzel(It.IsAny <int>())).Returns(new Puzzel());
var team = new TeamService(teamMock.Object,
spelerMock.Object,
sessieMock.Object,
puzzelMock.Object);
//Arrange
var teamIdActive = 2; //team 2 is bezig met een actieve puzzel
var teamIdNotActive = 1; //team1 is niet bezig met een puzzel
// Act
var resultActive = team.ActivePuzzel(teamIdActive);
var resultNotActive = team.ActivePuzzel(teamIdNotActive);
var activepuzzelID = team.GetActivePuzzel(1);
// Assert
Assert.IsType <Puzzel>(resultActive);
Assert.Equal(-1, activepuzzelID);
Assert.Null(resultNotActive);
}
public void SetupCheckpoints(params CheckpointFixture[] checkpoints)
{
if (checkpoints.GroupBy(h => h.Height).Any(g => g.Count() > 1))
{
throw new ArgumentException("Checkpoint heights must be unique.");
}
if (checkpoints.Any(h => h.Height < 0))
{
throw new ArgumentException("Checkpoint heights cannot be negative.");
}
foreach (CheckpointFixture checkpoint in checkpoints.OrderBy(h => h.Height))
{
var checkpointInfo = new CheckpointInfo(checkpoint.Header.GetHash());
this.checkpoints
.Setup(c => c.GetCheckpoint(checkpoint.Height))
.Returns(checkpointInfo);
}
this.checkpoints
.Setup(c => c.GetCheckpoint(It.IsNotIn(checkpoints.Select(h => h.Height))))
.Returns((CheckpointInfo)null);
this.checkpoints
.Setup(c => c.GetLastCheckpointHeight())
.Returns(checkpoints.OrderBy(h => h.Height).Last().Height);
this.checkpoints
.Setup(c => c.LastCheckpointHeight)
.Returns(checkpoints.OrderBy(h => h.Height).Last().Height);
}
public Task StartAsync_WhenExecuteAsyncThrow_ShouldInvokeExceptionHandler()
{
return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken =>
{
// Arrange.
this.subject.StubbedExecuteAsync
.Setup(f => f(It.IsAny <CancellationToken>()))
.ThrowsAsync(new Exception());
// Act.
await this.subject.StartAsync(cancellationToken);
await this.subject.StopAsync(CancellationToken.None);
// Assert.
this.subject.StubbedExecuteAsync.Verify(
f => f(It.IsNotIn(cancellationToken, CancellationToken.None)),
Times.Once()
);
this.subject.StubbedPostExecuteAsync.Verify(
f => f(CancellationToken.None),
Times.Once()
);
this.exceptionHandler.Verify(
h => h.RunAsync(this.subject.GetType(), It.Is <Exception>(ex => ex != null), CancellationToken.None),
Times.Once()
);
}));
}
