protected AppendEntryBaseTest()
{
// Arrange
var mocker = new AutoMocker();
ServerIdentifier = new ServerIdentifier();
mocker.Use(ServerIdentifier);
mocker.Setup<ISubject<AppendEntryMessage>>(p => p.Subscribe(It.IsAny<IObserver<AppendEntryMessage>>()))
.Callback<IObserver<AppendEntryMessage>>((o) =>
{
AppendEntryCallback = o;
});
AppendEntryCallback = mocker.Get<ISubject<AppendEntryMessage>>();
AppendEntryResult = new Subject<AppendEntryResultMessage>();
Election = new Election();
LogReplication = new LogReplication();
AppendEntry = new Rafting.AppendEntry(AppendEntryResult,
mocker.Get<ISubject<AppendEntryMessage>>(),
mocker.Get<IHartbeatTimer>(),
LogReplication,
Election,
mocker.Get<ILoggerFactory>(),
new RaftOptions(),
mocker.Get<ServerIdentifier>(),
null);
}
public void DisposeAndStateDoesNotChangeAfterHartbeatTest()
{
var mocker = new AutoMocker();
var serverIdentifier = new ServerIdentifier();
mocker.Use(serverIdentifier);
var options = new RaftOptions();
options.Hartbeat.FromMilliseconds = 50;
options.Hartbeat.ToMilliseconds = 50;
var timer = new HartbeatTimer(options, mocker.Get<ILoggerFactory>(), serverIdentifier);
var state = ServerStateType.Leader;
var dispose = timer.Subscribe((s) =>
{
state = s;
});
dispose.Dispose();
Thread.Sleep(100);
Assert.Equal(ServerStateType.Leader, state);
}
public void WHEN_facet_is_not_configured_in_SearchConfiguration_FacetSetting_SHOULD_return_Null()
{
//Arrange
var registry = _container.Get <IFacetProviderRegistry>();
var providerName = GetRandom.String(15);
registry.RegisterProvider(providerName, typeof(FakeFacetProvider));
var mockResolver = _container.GetMock <IDependencyResolver>();
mockResolver.Setup(dr => dr.Resolve(It.IsNotNull <Type>()))
.Returns(new FakeFacetProvider());
var sut = _container.CreateInstance <FacetFactory>();
var facet = new Facet {
FieldName = GetRandom.String(5)
};
var selectedFacets = new List <SearchFilter>();
var cultureInfo = new CultureInfo(CultureName);
//Act
var result = sut.CreateFacet(facet, selectedFacets, cultureInfo);
//Assert
result.Should().BeNull();
}
public void WhenDependencyResolverIsSpecifiedItInstance()
{
var mocker = new AutoMocker();
var service1 = mocker.Get <IService>();
var service2 = mocker.Get <IService2>();
var service3 = mocker.Get <IService3>();
var serviceProvider = mocker.GetMock <IServiceProvider>();
serviceProvider.Setup(x => x.GetService(typeof(IService))).Returns(service1).Verifiable();
serviceProvider.Setup(x => x.GetService(typeof(IService2))).Returns(service2).Verifiable();
serviceProvider.Setup(x => x.GetService(typeof(IService3))).Returns(service3).Verifiable();
DI.Dispose(typeof(ClassWithDependencies).Assembly);
DI.Init(typeof(IService).Assembly, builder =>
{
builder.WithProvider(serviceProvider.Object);
});
var sut = new ClassWithDependencies();
Assert.AreEqual(service1, sut.Service);
Assert.AreEqual(service2, sut.Service2);
Assert.AreEqual(service3, sut.Service3);
serviceProvider.Verify();
}
public void WHEN_passing_valid_arguments_SHOULD_create_viewmodel()
{
//Arrange
var expectedStatus = TestingExtensions.GetRandomEnum <MyAccountStatus>();
var param = new GetLoginViewModelParam
{
Status = expectedStatus,
CultureInfo = TestingExtensions.GetRandomCulture(),
Customer = MockCustomerFactory.CreateRandom(),
ReturnUrl = GetRandom.WwwUrl(),
LoginUrl = GetRandom.WwwUrl(),
CreateAccountUrl = GetRandom.WwwUrl(),
ForgotPasswordUrl = GetRandom.WwwUrl(),
Username = GetRandom.String(32)
};
var membershipViewService = _container.CreateInstance <MembershipViewService>();
membershipViewService.Membership = _container.Get <IMembershipProxy>();
//Act
var viewModel = membershipViewService.GetLoginViewModel(param);
//Assert
viewModel.Should().NotBeNull("This view model should never be null");
viewModel.Status.Should().Be(expectedStatus.ToString("G"), "Because we render the status as a string for HBS message switch");
viewModel.ReturnUrl.Should().Be(param.ReturnUrl);
viewModel.CreateAccountUrl.Should().Be(param.CreateAccountUrl);
viewModel.ForgotPasswordUrl.Should().Be(param.ForgotPasswordUrl);
viewModel.LoginUrl.Should().Be(param.LoginUrl);
viewModel.FirstName.Should().Be(param.Customer.FirstName);
viewModel.LastName.Should().Be(param.Customer.LastName);
}
public void CorrectSlotTheory(bool[] slotsClosed, int?nextSlot)
{
var sensors = new List <IDigitalSensor>();
var slots = new List <FeedingSlot>();
for (int i = 0; i < slotsClosed.Length; i++)
{
var sensor = new Mock <IDigitalSensor>();
sensor.Setup(s => s.Read()).Returns(slotsClosed[i]).Verifiable();
sensors.Add(sensor.Object);
slots.Add(new FeedingSlot(i.ToString(),
_mocker.Get <IGateDevice>(),
sensor.Object,
slots,
_mocker.Get <IThingsResource>()));
}
var manager = _mocker.CreateInstance <DefaultFeedingManager>();
manager.Slots = slots;
var result = manager.NextFeedingSlot();
_mocker.VerifyAll();
if (nextSlot.HasValue)
{
Assert.Equal(nextSlot.Value.ToString(), result.Name);
}
else
{
Assert.Null(result);
}
}
public async Task GetSelfUserAsync_WhenReadyIsNotComplete_WaitsForWhenReady()
{
var autoMocker = new AutoMocker();
var whenReadySource = new TaskCompletionSource <object>();
autoMocker.GetMock <IReadySynchronizationProvider>()
.Setup(x => x.WhenReady)
.Returns(() => whenReadySource.Task);
var selfUser = autoMocker.Get <ISocketSelfUser>();
autoMocker.GetMock <IDiscordSocketClient>()
.Setup(x => x.CurrentUser)
.Returns(() => autoMocker.Get <ISocketSelfUser>());
var uut = autoMocker.CreateInstance <SelfUserProvider>();
var result = uut.GetSelfUserAsync();
result.IsCompleted.ShouldBeFalse();
whenReadySource.SetResult(null);
await result;
result.IsCompleted.ShouldBeTrue();
result.Result.ShouldBeSameAs(selfUser);
}
public CandidateBaseTests()
{
var mocker = new AutoMocker();
ServerIdentifier = new ServerIdentifier();
mocker.Use(ServerIdentifier);
Election = new Election();
RequestVoteResult = new Subject<RequestVoteResultMessage>();
RequestVote = new Subject<RequestVoteMessage>();
MockVotingSystem = mocker.GetMock<IVotingSystem>();
Candidate = new Rafting.States.Candidate(mocker.Get<ServerIdentifier>(),
mocker.Get<IElectionTimer>(),
RequestVote,
RequestVoteResult,
MockVotingSystem.Object,
Election,
mocker.Get<ILogReplication>(),
mocker.Get<Nodes>(),
mocker.Get<ILoggerFactory>(),
new RaftOptions());
}
public void You_can_setup_a_mock_using_the_classic_Setup_style()
{
mocker.Setup <IService2>(x => x.Other).Returns(Mock.Of <IService1>());
var mock = mocker.Get <IService2>();
mock.ShouldNotBeNull();
mock.Other.ShouldNotBeNull();
}
public void ConstructorParametersCanBeMocked()
{
var mocker = new AutoMocker();
var sut = mocker.CreateInstance <ClassWithDependencies>();
Assert.AreEqual(mocker.Get <IService>(), sut.Service);
Assert.AreEqual(mocker.Get <IService2>(), sut.Service2);
}
/// <summary>
/// Get <see cref="FeedingSlot"/>
/// </summary>
/// <param name="mocker">Instance of <see cref="AutoMocker"/></param>
/// <param name="name">Name of the slot</param>
/// <param name="sensor">The sensor to link with the <see cref="FeedingSlot"/></param>
/// <returns></returns>
public static FeedingSlot GetSlotWithSensor(this AutoMocker mocker, string name, Mock <IDigitalSensor> sensor)
{
return(new FeedingSlot(name,
mocker.Get <IGateDevice>(),
sensor.Object,
Enumerable.Empty <FeedingSlot>(),
mocker.Get <IThingsResource>()));
}
public void Convenience_methods_work()
{
var mocker = new AutoMocker();
mocker.Combine <IService1, IService2, IService3>();
Assert.AreSame(mocker.Get <IService2>(), mocker.Get <IService1>());
Assert.AreSame(mocker.Get <IService3>(), mocker.Get <IService2>());
}
public void Combine_method_should_maintain_setups()
{
var mocker = new AutoMocker(MockBehavior.Loose);
mocker.GetMock <IDerivedInterface>().Setup(x => x.Foo()).Returns(() => "42");
mocker.Combine(typeof(IDerivedInterface), typeof(IBaseInterface));
Assert.AreEqual("42", mocker.Get <IBaseInterface>().Foo());
Assert.AreEqual("42", mocker.Get <IDerivedInterface>().Foo());
}
public void It_extracts_instances_that_were_placed_with_Use()
{
var setupInstance = Mock.Of <IService1>();
mocker.Use(setupInstance);
var actualInstance = mocker.Get <IService1>();
actualInstance.ShouldBeSameAs(setupInstance);
}
public void It_uses_the_same_mock_for_all_instances()
{
var mocker = new AutoMocker();
mocker.Combine(typeof(IService1), typeof(IService2),
typeof(IService3));
Assert.AreSame(mocker.Get <IService2>(), mocker.Get <IService1>());
Assert.AreSame(mocker.Get <IService3>(), mocker.Get <IService2>());
}
public void ConstructorParametersCanBeMocked()
{
var mocker = new AutoMocker();
var sut = mocker.CreateInstance <ClassWithDependencies>();
Assert.AreEqual(mocker.Get <IService>(), sut.Service);
Assert.AreEqual(mocker.Get <IService2>(), sut.Service2);
//Property wont resolve because there is no resolver specified
Assert.IsNull(sut.Service3);
}
public void It_extracts_instances_that_were_placed_with_Use()
{
var setupInstance = Mock.Of <IService1>();
mocker.Use(setupInstance);
var actualInstance = mocker.Get <IService1>();
Assert.AreSame(setupInstance, actualInstance);
}
public void You_can_verify_a_method_that_returns_a_value_type()
{
mocker.Setup <IServiceWithPrimitives, long>(s => s.ReturnsALong()).Returns(100L);
var mock = mocker.Get <IServiceWithPrimitives>();
mock.ReturnsALong().ShouldEqual(100L);
mocker.Verify <IServiceWithPrimitives, long>(s => s.ReturnsALong(), Times.Once());
}
public void Init()
{
var mocker = new AutoMocker();
var machine = new Machine<State, Trigger>(State.First,
mocker.Get<ILoggerFactory>(),
mocker.Get<IObservableProvider>());
machine.On(State.First).
OnEntry(() =>
{
Assert.Equal(State.First, machine.State);
System.Console.WriteLine($"first {machine.State}");
})
.Permit(Trigger.ChangeToSecond, State.Second)
.Permit(Trigger.ChangeToFirst, State.First);
machine.On(State.Second).
OnEntry(() =>
{
Assert.Equal(State.Second, machine.State);
System.Console.WriteLine($"second {machine.State}");
})
.Permit(Trigger.ChangeToSecond, State.Second)
.Permit(Trigger.ChangeToThird, State.Third);
machine.On(State.Third).
OnEntry(() =>
{
Assert.Equal(State.Third, machine.State);
});
machine.OnNext(Trigger.ChangeToFirst);
Assert.Equal(State.First, machine.State);
machine.OnNext(Trigger.ChangeToThird);
Assert.Equal(State.First, machine.State);
machine.OnNext(Trigger.ChangeToSecond);
Assert.Equal(State.Second, machine.State);
machine.OnNext(Trigger.ChangeToThird);
Assert.Equal(State.Third, machine.State);
machine.OnNext(Trigger.ChangeToFirst);
}
public void UseConcreteClassFor()
{
AutoMocker <ConcreteClass> mocker = createAutoMocker <ConcreteClass>();
mocker.UseConcreteClassFor <ConcreteThing>();
var thing = mocker.Get <ConcreteThing>();
thing.ShouldBeOfType <ConcreteThing>();
Assert.AreSame(mocker.Get <IMockedService>(), thing.Service);
Assert.AreSame(mocker.Get <IMockedService2>(), thing.Service2);
}
public void UseConcreteClassFor()
{
AutoMocker <ConcreteClass> mocker = createAutoMocker <ConcreteClass>();
mocker.UseConcreteClassFor <ConcreteThing>();
var thing = mocker.Get <ConcreteThing>();
Assert.IsInstanceOfType(typeof(ConcreteThing), thing);
Assert.AreSame(mocker.Get <IMockedService>(), thing.Service);
Assert.AreSame(mocker.Get <IMockedService2>(), thing.Service2);
}
public async Task CreateTag_TagAlreadyExistsWithSameCasing_Throws()
{
var botContext = _autoMocker.Get <BotContext>();
await botContext.Tags.AddAsync(new TagEntity()
{
Name = "tag"
});
await botContext.SaveChangesAsync();
await Assert.ThrowsAsync <InvalidOperationException>(
() => _tagService.CreateTagAsync(0, 0, "tag", "content"));
}
public void It_uses_the_same_mock_for_all_instances()
{
mocker.Combine(typeof(IService1), typeof(IService2),
typeof(IService3));
Assert.Same(mocker.Get <IService2>(), mocker.Get <IService1>());
Assert.Same(mocker.Get <IService3>(), mocker.Get <IService2>());
}
public void TheAutoMockerPushesInMocksForAllOfTheConstructorArgumentsForAPartialMock()
{
AutoMocker <ConcreteClass> autoMocker = createAutoMocker <ConcreteClass>();
var service = autoMocker.Get <IMockedService>();
var service2 = autoMocker.Get <IMockedService2>();
var service3 = autoMocker.Get <IMockedService3>();
autoMocker.PartialMockTheClassUnderTest();
ConcreteClass concreteClass = autoMocker.ClassUnderTest;
Assert.AreSame(service, concreteClass.Service);
Assert.AreSame(service2, concreteClass.Service2);
Assert.AreSame(service3, concreteClass.Service3);
}
public void ResolvesFuncReturningDefinedParameter(Type delegateType, object expected)
{
if (delegateType is null)
{
throw new ArgumentNullException(nameof(delegateType));
}
if (expected is null)
{
throw new ArgumentNullException(nameof(expected));
}
var mocker = new AutoMocker {
Resolvers = { new FuncResolver() }
};
mocker.Use(expected.GetType(), expected);
var func = (Delegate)mocker.Get(delegateType) !;
Assert.IsNotNull(func);
var @params = new object[delegateType.GetGenericArguments().Length - 1];
Assert.AreEqual(expected, func.DynamicInvoke(@params));
}
public void It_Returns_Achievement_Details_For_The_Current_User()
{
//--arrange
var achievementId = AchievementId.BusyBee;
var expectedPlayerAchievementDetails = new PlayerAchievementDetails();
AutoMocker.Get <IPlayerAchievementRetriever>().Expect(mock => mock.GetPlayerAchievement(Arg <PlayerAchievementQuery> .Is.Anything))
.Return(expectedPlayerAchievementDetails);
var expectedPlayerAchievementViewModel = new PlayerAchievementViewModel();
AutoMocker.Get <ITransformer>().Expect(mock => mock.Transform <PlayerAchievementViewModel>(expectedPlayerAchievementDetails))
.Return(expectedPlayerAchievementViewModel);
//--act
var viewResult = AutoMocker.ClassUnderTest.DetailsForCurrentUser(achievementId, CurrentUser) as ViewResult;
//--assert
viewResult.ShouldNotBeNull();
viewResult.ViewName.ShouldBe(MVC.Achievement.Views.Details);
var firstCall =
AutoMocker.Get <IPlayerAchievementRetriever>()
.GetArgumentsForCallsMadeOn(x => x.GetPlayerAchievement(Arg <PlayerAchievementQuery> .Is.Anything));
var query = firstCall.AssertFirstCallIsType <PlayerAchievementQuery>();
query.AchievementId.ShouldBe(achievementId);
query.ApplicationUserId.ShouldBe(CurrentUser.Id);
query.GamingGroupId.ShouldBe(CurrentUser.CurrentGamingGroupId);
var playerAchievementViewModel = viewResult.Model as PlayerAchievementViewModel;
playerAchievementViewModel.ShouldBe(expectedPlayerAchievementViewModel);
}
public void It_Sets_The_WinnerType_Based_On_The_Ranks_Of_The_Players()
{
//--arrange
var playerGameResults = new List <PlayerGameResult>
{
new PlayerGameResult
{
GameRank = 1
},
new PlayerGameResult
{
GameRank = 2
}
};
var expectedWinnerType = WinnerTypes.TeamLoss;
AutoMocker.Get <IWinnerTypeCalculator>()
.Expect(mock => mock.CalculateWinnerType(Arg <IList <int> > .Is.Anything)).Return(expectedWinnerType);
//--act
var result = AutoMocker.ClassUnderTest.TransformNewlyCompletedGameIntoPlayedGame(new NewlyCompletedGame(), GAMING_GROUP_ID, CurrentUser.Id, playerGameResults);
//--assert
var arguments = AutoMocker.Get <IWinnerTypeCalculator>()
.GetArgumentsForCallsMadeOn(mock => mock.CalculateWinnerType(Arg <IList <int> > .Is.Anything));
var gameRanks = arguments.AssertFirstCallIsType <IList <int> >();
gameRanks.ShouldContain(playerGameResults[0].GameRank);
gameRanks.ShouldContain(playerGameResults[1].GameRank);
result.WinnerType.ShouldBe(expectedWinnerType);
}
public async Task DeleteTag_OwnerIdDoesntMatch_Throws()
{
var botContext = _autoMocker.Get <BotContext>();
var entity = new TagEntity()
{
Name = "name",
OwnerId = 0
};
await botContext.Tags.AddAsync(entity);
await botContext.SaveChangesAsync();
await Assert.ThrowsAsync <InvalidOperationException>(
() => _tagService.DeleteTagAsync(0, 1, "name"));
}
public void It_creates_a_mock_if_the_object_is_missing_using_Get()
{
var mocker = new AutoMocker();
var mock = mocker.Get <IService1>();
Assert.IsNotNull(mock);
}
public async Task DeleteAccount_PostsNotification()
{
//Arrange
var mocker = new AutoMocker().WithMessenger();
var watcher = new MessageWatcher <DatabaseEvent <Account> >();
mocker.Get <IMessenger>().Register(watcher);
using var factory = mocker.WithDbScope();
var account1 = new Account();
using var setupContext = factory.Create();
setupContext.Accounts.Add(account1);
await setupContext.SaveChangesAsync();
//Act
using var actContext = factory.Create();
var account = await actContext.Accounts.FindAsync(account1.ID);
actContext.Accounts.Remove(account);
await actContext.SaveChangesAsync();
//Assert
DatabaseEvent <Account>?message = watcher.Messages.Last();
Assert.AreEqual(account1.ID, message.Item.ID);
Assert.AreEqual(EventType.Deleted, message.Type);
}
public override void SetUp()
{
base.SetUp();
gamingGroupList = new List <GamingGroup>
{
new GamingGroup
{
Id = gamingGroupId1,
UserGamingGroups = new List <UserGamingGroup>
{
new UserGamingGroup
{
ApplicationUserId = CurrentUser.Id
}
}
},
new GamingGroup
{
Id = gamingGroupId2,
UserGamingGroups = new List <UserGamingGroup>
{
new UserGamingGroup
{
ApplicationUserId = "some other application id"
}
}
}
};
AutoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <GamingGroup>())
.Return(gamingGroupList.AsQueryable());
}
public void UseTheAutoMockerToStartUpTheConcreteClass()
{
AutoMocker <ConcreteClass> autoMocker = createAutoMocker <ConcreteClass>();
setExpectation(autoMocker.Get <IMockedService>(), x => x.Name, "Jeremy");
autoMocker.ClassUnderTest.Name.ShouldEqual("Jeremy");
}
public override void SetUp()
{
base.SetUp();
var notExistingPlayerName = "not exists";
Request.PlayerRanks = new List <CreatePlayerRankRequest>
{
new CreatePlayerRankRequest
{
GameRank = 1,
PlayerId = 1,
PlayerName = "existing player"
},
new CreatePlayerRankRequest
{
GameRank = 2,
PlayerName = notExistingPlayerName
}
};
AutoMocker.Get <IPlayerSaver>()
.Expect(
x =>
x.CreatePlayer(
Arg <CreatePlayerRequest> .Matches(
m => m.Name == notExistingPlayerName), Arg <ApplicationUser> .Is.Equal(CurrentUser), Arg <bool> .Is.Anything))
.Repeat.Once().Return(new Player {
Id = 2
});
}
public void TheAutoMockerPushesInMocksAndAPreBuiltStubForAllOfTheConstructorArguments()
{
AutoMocker <ConcreteClass> autoMocker = createAutoMocker <ConcreteClass>();
var stub = new StubService();
autoMocker.Inject <IMockedService>(stub);
var service2 = autoMocker.Get <IMockedService2>();
var service3 = autoMocker.Get <IMockedService3>();
ConcreteClass concreteClass = autoMocker.ClassUnderTest;
Assert.AreSame(stub, concreteClass.Service);
Assert.AreSame(service2, concreteClass.Service2);
Assert.AreSame(service3, concreteClass.Service3);
}
public void TestGetCloudantSecurityDocument_Should_Return_A_Valid_Document()
{
//SETUP
var mocker = new AutoMocker();
//connection returns base uri
mocker.Setup<ICouchConnection>(c => c.BaseUri).Returns(new Uri("http://localhost"));
//GetCouchResponse returns security doc as per Cloudant documentation
const string responseString = "{ " +
"\"_id\":\"_security\"," +
"\"cloudant\":" +
"{" +
" \"userwithreadonlyaccess\": [" +
" \"_reader\"" +
" ]," +
" \"userwithreadandwriteaccess\": [" +
" \"_reader\"," +
" \"_writer\"" +
" ]" +
"}," +
"\"ok\":true" +
"}";
mocker.Setup<ICouchResponse>(r => r.ResponseString).Returns(responseString);
mocker.Setup<ICouchResponse, HttpStatusCode>(r => r.StatusCode).Returns(HttpStatusCode.OK);
mocker.Setup<ICouchRequest>(r => r.GetCouchResponse()).Returns(mocker.Get<ICouchResponse>());
//couchFactory returns request
mocker.Setup<ICouchFactory>(f => f.GetRequest(It.IsAny<Uri>(), It.IsAny<ICouchConnection>()))
.Returns(mocker.Get<ICouchRequest>());
//Get request returns request
mocker.Setup<ICouchRequest>(r => r.Get()).Returns(mocker.Get<ICouchRequest>());
//Json content type returns request
mocker.Setup<ICouchRequest>(r => r.Json()).Returns(mocker.Get<ICouchRequest>());
//TEST
var database = mocker.CreateInstance<CloudantDatabase>();
var securityDocument = (CloudantSecurityDocument)database.GetSecurityDocument();
securityDocument.Id.Should().Be("_security");
securityDocument.CloudantSecuritySection.GetAssignment("userwithreadonlyaccess").Should().BeEquivalentTo("_reader");
securityDocument.CloudantSecuritySection.GetAssignment("userwithreadandwriteaccess").Should().BeEquivalentTo("_reader", "_writer");
securityDocument.Ok.Should().BeTrue();
mocker.VerifyAll();
}
protected VoteReceivedBaseTests()
{
// Arrange
var mocker = new AutoMocker();
ServerIdentifier = new ServerIdentifier();
mocker.Use(ServerIdentifier);
mocker.Setup<ISubject<RequestVoteMessage>>(p => p.Subscribe(It.IsAny<IObserver<RequestVoteMessage>>()))
.Callback<IObserver<RequestVoteMessage>>((o) =>
{
RequestVoteCallback = o;
});
RequestVoteCallback = mocker.Get<ISubject<RequestVoteMessage>>();
Election = new Election();
Message = new RequestVoteResultMessage();
mocker.Setup<ISubject<RequestVoteResultMessage>>(p => p.OnNext(It.IsAny<RequestVoteResultMessage>()))
.Callback<RequestVoteResultMessage>((o) =>
{
Message = o;
});
VoteReceived = new Rafting.VoteReceived(mocker.Get<ISubject<RequestVoteResultMessage>>(),
mocker.Get<ServerIdentifier>(),
mocker.Get<ISubject<RequestVoteMessage>>(),
Election,
mocker.Get<ILoggerFactory>(),
new Nodes(),
new RaftOptions(),
mocker.Get<ILogReplication>());
}
public void ChangeStates()
{
// Arrange
var mocker = new AutoMocker();
mocker.Setup<IHartbeatTimer>(p => p.Reset()).Callback(() =>
{
});
var mockFollower = mocker.GetMock<Follower>();
var mockCandidate = mocker.GetMock<Candidate>();
var mockLeader = mocker.GetMock<Leader>();
mocker.Setup<IObservableProvider>(p => p.GetObservable<Follower, ServerStateType>())
.Returns(mockFollower.Object);
mocker.Setup<IObservableProvider>(p => p.GetObservable<Candidate, ServerStateType>())
.Returns(mockCandidate.Object);
mocker.Setup<IObservableProvider>(p => p.GetObservable<Leader, ServerStateType>())
.Returns(mockLeader.Object);
Machine<ServerStateType, ServerStateType> machine = null;
mocker.Setup<IHartbeatTimer>(p => p.Subscribe(It.IsAny<Machine<ServerStateType, ServerStateType>>()))
.Returns(new Disposable())
.Callback<Machine<ServerStateType, ServerStateType>>(m =>
{
machine = m;
});
var node = new Node(mocker.Get<IVoteReceived>(),
mocker.Get<IAppendEntry>(),
mocker.Get<IHartbeatTimer>(),
mocker.Get<ILoggerFactory>(),
mocker.Get<IObservableProvider>(),
mocker.Get<ILogReplication>(),
mocker.Get<ServerIdentifier>());
var mockHartbeat = mocker.GetMock<IHartbeatTimer>();
// Assert
Assert.Equal(ServerStateType.Follower, node.State);
machine.OnNext(ServerStateType.Candidate);
Assert.Equal(ServerStateType.Candidate, node.State);
machine.OnNext(ServerStateType.Leader);
}
public void SubscribeTest()
{
var mocker = new AutoMocker();
var serverIdentifier = new ServerIdentifier();
mocker.Use(serverIdentifier);
var options = new RaftOptions();
options.Hartbeat.FromMilliseconds = 0;
options.Hartbeat.ToMilliseconds = 0;
var timer = new HartbeatTimer(options, mocker.Get<ILoggerFactory>(), serverIdentifier);
var state = ServerStateType.Leader;
timer.Subscribe((s) =>
{
state = s;
});
Thread.Sleep(100);
Assert.Equal(ServerStateType.Candidate, state);
}
public void TestUpdateSecurityDoc_Should_Succeed_For_Valid_Document()
{
//SETUP
var mocker = new AutoMocker();
//connection returns base uri
mocker.Setup<ICouchConnection>(c => c.BaseUri).Returns(new Uri("http://localhost"));
//GetCouchResponse returns security doc as per Cloudant documentation
const string responseString = "{ " +
"\"ok\":true" +
"}";
mocker.Setup<ICouchResponse>(r => r.ResponseString).Returns(responseString);
mocker.Setup<ICouchResponse, HttpStatusCode>(r => r.StatusCode).Returns(HttpStatusCode.OK);
mocker.Setup<ICouchRequest>(r => r.GetCouchResponse()).Returns(mocker.Get<ICouchResponse>());
//couchFactory returns request
mocker.Setup<ICouchFactory>(f => f.GetRequest(It.IsAny<Uri>(), It.IsAny<ICouchConnection>()))
.Returns(mocker.Get<ICouchRequest>());
//Get request returns request
mocker.Setup<ICouchRequest>(r => r.Put()).Returns(mocker.Get<ICouchRequest>());
//Json content type returns request
mocker.Setup<ICouchRequest>(r => r.Json()).Returns(mocker.Get<ICouchRequest>());
//Data returns request
mocker.Setup<ICouchRequest>(r => r.Data(It.IsAny<string>())).Returns(mocker.Get<ICouchRequest>());
//security doc
var securityDoc = new CloudantSecurityDocument();
securityDoc.CloudantSecuritySection.AddUser("user1", "_reader");
securityDoc.CloudantSecuritySection.AddUser("user2", "_reader","_writer");
//TEST
var database = mocker.CreateInstance<CloudantDatabase>();
database.UpdateSecurityDocument(securityDoc);
mocker.VerifyAll();
}
public LeaderBaseTests()
{
var mocker = new AutoMocker();
ServerIdentifier = new ServerIdentifier();
mocker.Use(ServerIdentifier);
Election = new Election();
AppendEntryResult = new Subject<AppendEntryResultMessage>();
AppendEntry = new Subject<AppendEntryMessage>();
LogReplication = new LogReplication();
Nodes = new Nodes();
Leader = new Rafting.States.Leader(
Election,
mocker.Get<IHartbeatTimer>(),
AppendEntryResult,
AppendEntry,
mocker.Get<IObserver<ClientResultMessage>>(),
mocker.Get<IObservable<ClientMessage>>(),
LogReplication,
Nodes,
mocker.Get<ILoggerFactory>(),
new RaftOptions(),
mocker.Get<ServerIdentifier>());
}