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 async Task WHEN_passing_valid_arguments_SHOULD_create_viewmodel()
{
//Arrange
var customer = MockCustomerFactory.CreateRandom();
var mockedCustomerRepository = new Mock <ICustomerRepository>();
mockedCustomerRepository.Setup(r => r.GetCustomerByIdAsync(It.Is <GetCustomerByIdParam>(p => p.CustomerId == customer.Id)))
.ReturnsAsync(customer);
_container.Use(mockedCustomerRepository);
var expectedStatus = TestingExtensions.GetRandomEnum <MyAccountStatus>();
var param = new GetUpdateAccountViewModelParam
{
Status = expectedStatus,
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = customer.Id,
ReturnUrl = GetRandom.WwwUrl(),
Scope = GetRandom.String(32)
};
var customerViewService = _container.CreateInstance <CustomerViewService>();
//Act
var viewModel = await customerViewService.GetUpdateAccountViewModelAsync(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.Email.Should().Be(customer.Email);
viewModel.FirstName.Should().Be(customer.FirstName);
viewModel.LastName.Should().Be(customer.LastName);
}
public TabViewModelTests()
{
_autoMocker = new AutoMocker();
_autoMocker
.Setup <IPathService, string>(m => m.RightTrimPathSeparators(CurrentDirectory))
.Returns(CurrentDirectory);
_autoMocker
.Setup <IPathService, string>(m => m.GetFileName(CurrentDirectory))
.Returns(CurrentDirectoryName);
_autoMocker
.Use(new TabConfiguration
{
MaxHistorySize = 100
});
_autoMocker.Use(new TabStateModel
{
Directory = CurrentDirectory,
History = new List <string> {
PrevDirectory, CurrentDirectory, NextDirectory
},
SortingSettings = new SortingSettingsStateModel(),
CurrentPositionInHistory = 1
});
_tabViewModel = _autoMocker.CreateInstance <TabViewModel>();
}
public void SetUp()
{
_container = new AutoMocker();
_container.Use(MockMyAccountUrlProviderFactory.Create());
_container.Use(MockViewModelMapperFactory.Create(typeof(EditAddressViewModel).Assembly));
_container.Use(CreateCountryServiceMock());
}
public void CalculateTotals_CombineTheCouponDataWithShoppingCart()
{
var fakeCouponRepository = _mocker.GetMock <ICouponRepository>();
fakeCouponRepository
.Setup(x => x.FindById("coupon-1"))
.Returns(CreateCoupon("coupon-1", CouponType.Amount, 100));
var fakeCartRepository = _mocker.GetMock <IShoppingCartRepository>();
fakeCartRepository.Setup(x => x.FindById("cart-1"))
.Returns(new CartBuilder().WithId("cart-1").Build());
var fakeCheckoutEngine = _mocker.GetMock <ICheckOutEngine>();
fakeCheckoutEngine
.Setup(x => x.CalculateTotals(It.IsAny <Cart>()))
.Returns(CreateCheckOutDto(total: 150));
_mocker.Use <ICouponEngine>(new CouponEngine());
var target = _mocker.CreateInstance <ShoppingCartManager>();
var result = target.CalculateTotals("cart-1", "coupon-1");
Assert.Equal(100, result.CouponDiscount);
}
public async Task Handler_ValidRequest_RoomIsCreated()
{
//arrange
var mocker = new AutoMocker();
var buildingId = 1;
mocker.Use(MapperProfileBuilder.Mapper);
var context = InMemoryContext.Create();
context.Buildings.Add(new Building()
{
Id = 1
});
context.SaveChanges();
mocker.Use <IReservationDbContext>(context);
//act
var handler = mocker.CreateInstance <CreateRoomCommand.Handler>();
await handler.Handle(new CreateRoomCommand()
{
BuildingId = buildingId
}, CancellationToken.None);
//assert
context.Rooms.Count().Should().Be(1);
context.Dispose();
}
public async Task Handler_RoomCreated_SendsNotification()
{
//arrange
var hasBeenCalled = false;
var mocker = new AutoMocker();
var buildingId = 1;
mocker.Use(MapperProfileBuilder.Mapper);
mocker.GetMock <IMediator>().Setup(x => x.Publish(It.IsNotNull <RoomCreated>(), It.IsAny <CancellationToken>()))
.Callback(() => hasBeenCalled = true);
var context = InMemoryContext.Create();
context.Buildings.Add(new Building()
{
Id = 1
});
context.SaveChanges();
mocker.Use <IReservationDbContext>(context);
//act
var handler = mocker.CreateInstance <CreateRoomCommand.Handler>();
await handler.Handle(new CreateRoomCommand()
{
BuildingId = buildingId
}, CancellationToken.None);
//assert
hasBeenCalled.Should().BeTrue();
context.Dispose();
}
private Mock <IHcFaceDetection> SetupHcFaceDetection()
{
var mFaceDetection = new Mock <IHcFaceDetection>();
_mocker.Use <IHcFaceDetection>(mFaceDetection.Object);
return(mFaceDetection);
}
public void SetUp()
{
_container = new AutoMocker();
_container.Use(CreateDamProvider());
_container.Use(FakeViewModelMapper.CreateFake(typeof(ProductPriceViewService).Assembly));
_container.Use(CreateLocalizationProvider());
}
public void SetUp()
{
//Arrange
_container = new AutoMocker();
_container.Use(CreateWishListUrlProvider());
_container.Use(CreateLineItemService());
}
public void SetUp()
{
//Arrange
_container = new AutoMocker();
_container.Use(ViewModelMapperFactory.Create());
_container.Use(CartViewModelFactoryMock.Create());
var cartRepoMock = _container.GetMock <ICartRepository>();
cartRepoMock.Setup(repo => repo.CompleteCheckoutAsync(It.IsNotNull <CompleteCheckoutParam>()))
.Returns((CompleteCheckoutParam p) =>
{
var order = new Overture.ServiceModel.Orders.Order
{
Cart = new ProcessedCart()
{
Customer = new CustomerSummary()
{
Email = GetRandom.Email()
},
Shipments = new System.Collections.Generic.List <Shipment>()
{
new Shipment
{
Id = GetRandom.Guid(),
LineItems = new System.Collections.Generic.List <LineItem>()
{
new LineItem
{
Id = GetRandom.Guid(),
Sku = GetRandom.String(10),
CatalogId = GetRandom.String(10),
PlacedPrice = GetRandom.Decimal(),
PlacedQuantity = GetRandom.Int(),
Status = GetRandom.String(5),
Total = GetRandom.Decimal(),
KvaValues = new Overture.ServiceModel.PropertyBag(),
KvaDisplayValues = new Overture.ServiceModel.PropertyBag(),
ProductSummary = new CartProductSummary
{
Brand = null,
DisplayName = GetRandom.String(10),
PrimaryParentCategoryId = GetRandom.String(10)
}
}
},
FulfillmentMethod = new FulfillmentMethod
{
FulfillmentMethodType = FulfillmentMethodType.PickUp
}
}
}
},
OrderNumber = GetRandom.String(12)
};
return(Task.FromResult(order));
});
}
public async Task GetTemperatureAsync_ShouldUseFirstLocation()
{
var mocker = new AutoMocker(MockBehavior.Strict);
mocker.GetMock <ILocationService>()
.Setup(x => x.GeocodeAsync("Minsk"))
.ReturnsAsync(new[] { new GeoLocation {
Lat = 1, Lon = 1
}, new GeoLocation {
Lat = 2, Lon = 2
} });
mocker.GetMock <IWeatherService>().Setup(x => x.GetWeatherAsync(It.Is <GeoLocation>(l => l.Lat == 1 && l.Lon == 1)))
.ReturnsAsync(new Weather
{
Condition = Condition.Sunny,
Temperature = 232.8,
Description = "Hot"
});
mocker.Use <IMemoryCache>(new MemoryCache(Options.Create(new MemoryCacheOptions())));
mocker.Use <ILogger <SmartWeatherService> >(new NullLogger <SmartWeatherService>());
var service = mocker.CreateInstance <SmartWeatherService>();
var actualWeather = await service.GetRealTimeWeatherAsync("Minsk");
actualWeather.Should().BeEquivalentTo(new
{
Temperature = 232.8,
Condition = Condition.Sunny,
});
}
public void SetUp()
{
_container = new AutoMocker();
_container.Use(MockMyAccountUrlProviderFactory.Create());
_container.Use(MockViewModelMapperFactory.Create(typeof(SignInHeaderViewModel).Assembly));
_container.Use(new Mock <IMembershipProxy>(MockBehavior.Strict));
}
public void SetUp()
{
Container = new AutoMocker();
Container.Use(_mapper);
Container.Use(LocalizationProviderFactory.Create());
}
public void SetUp()
{
Container = new AutoMocker();
Container.Use(FulfillmentRepositoryMock.MockFulfillmentRepoWithRandomMethods());
Container.Use(CartViewModelFactoryMock.MockGetShippingMethodViewModel());
}
public async Task TestUnLoadFailAction()
{
var autoMock = new AutoMocker();
var objectFactory = new Mock <IObjectFactory>();
var guid = Guid.NewGuid();
var pluginMock = new Mock <IPlugins>();
var pluginLoaderMock = new Mock <IPluginLoader>();
objectFactory.Setup(t => t.Create <ConcurrentDictionary <Guid, IPlugins> >()).
Returns(new ConcurrentDictionary <Guid, IPlugins>()
{
[guid] = pluginMock.Object
});
pluginMock.Setup(t => t.Key).Returns(guid);
pluginLoaderMock.Setup(t => t.UnLoad(guid)).Returns(new ValueTask <bool>(false));
var unLoaderActionMock = new Mock <IPluginUnLoadAction>();
autoMock.Use(unLoaderActionMock.Object);
autoMock.Use(pluginLoaderMock.Object);
autoMock.Use(objectFactory.Object);
var ins = autoMock.CreateInstance <PluginManagers>();
await ins.Remove(pluginMock.Object);
unLoaderActionMock.Verify(t => t.Invoke(It.IsAny <Guid>()), Times.Never);
}
public void It_creates_mock_objects_for_ctor_sealed_parameters_when_instances_provided()
{
mocker.Use("Hello World");
WithSealedParams instance = mocker.CreateInstance <WithSealedParams>();
instance.Sealed.ShouldNotBeNull().ShouldEqual("Hello World");
}
public async Task WHEN_passing_valid_arguments_SHOULD_create_viewmodel()
{
//Arrange
var customer = MockCustomerFactory.CreateRandom();
var mockedCustomerRepository = new Mock <ICustomerRepository>();
mockedCustomerRepository.Setup(r => r.GetCustomerByIdAsync(It.IsAny <GetCustomerByIdParam>())).ReturnsAsync(customer);
mockedCustomerRepository.Setup(r => r.UpdateUserAsync(It.IsAny <UpdateUserParam>())).ReturnsAsync(customer);
_container.Use(mockedCustomerRepository);
var customerViewService = _container.CreateInstance <CustomerViewService>();
//Act
var viewModel = await customerViewService.UpdateAccountAsync(new UpdateAccountParam
{
ReturnUrl = GetRandom.String(32),
Scope = GetRandom.String(32),
CustomerId = Guid.NewGuid(),
CultureInfo = TestingExtensions.GetRandomCulture(),
Email = GetRandom.String(32),
FirstName = GetRandom.String(32),
LastName = GetRandom.String(32),
PreferredLanguage = GetRandom.String(4),
});
//Assert
viewModel.Should().NotBeNull();
viewModel.FirstName.Should().Be(customer.FirstName);
}
public async Task CreateAdviseGroup_IfShowCreateAdviseGroupViewReturnsNotNull_CreatesAdviseGroup()
{
// Arrange
var adviseGroupHelperMock = new Mock <IAdviseGroupHelper>();
adviseGroupHelperMock.Setup(x => x.AdviseGroups).Returns(Array.Empty <AdviseGroupModel>());
var viewNavigatorStub = new Mock <IViewNavigator>();
viewNavigatorStub.Setup(x => x.ShowCreateAdviseGroupView(It.IsAny <string>(), It.IsAny <IEnumerable <string> >())).Returns("Some New Group");
var mocker = new AutoMocker();
mocker.Use(adviseGroupHelperMock);
mocker.Use(viewNavigatorStub);
var adviseGroupHolder = Mock.Of <BasicAdviseGroupHolder>();
var target = mocker.CreateInstance <LibraryExplorerViewModel>();
// Act
await target.CreateAdviseGroup(adviseGroupHolder, CancellationToken.None);
// Assert
adviseGroupHelperMock.Verify(x => x.CreateAdviseGroup(adviseGroupHolder, "Some New Group", It.IsAny <CancellationToken>()), Times.Once);
}
public async Task WHEN_passing_valid_arguments_SHOULD_create_viewmodel()
{
//Arrange
var addressId = Guid.NewGuid();
var customer = new Customer
{
AddressIds = new List <Guid> {
addressId
}
};
var mockedCustomerRepository = new Mock <ICustomerRepository>();
mockedCustomerRepository.Setup(r => r.GetCustomerByIdAsync(It.IsAny <GetCustomerByIdParam>())).ReturnsAsync(customer);
_container.Use(mockedCustomerRepository);
var customerViewService = _container.CreateInstance <CustomerAddressViewService>();
//Act
var viewModel = await customerViewService.DeleteAddressAsync(new DeleteAddressParam
{
Scope = GetRandom.String(32),
CustomerId = Guid.NewGuid(),
AddressId = addressId
});
//Assert
viewModel.Should().NotBeNull();
}
public void SetUp()
{
_container = new AutoMocker();
_container.Use(CreateStoreUrlProvider());
_container.Use(CreateStoreRepository(StoresNumbers));
_container.Use(CreateStoreViewModelFactory(StoresNumbers));
}
public void SetUp()
{
Container = new AutoMocker();
Container.Use(ViewModelMapperFactory.Create());
Container.Use(LocalizationProviderFactory.Create());
Container.Use(CartViewModelFactoryMock.Create());
}
public async Task PlayPlaylistStartingFromSongEventHandler_IfSomeSongIsPlaying_StartsPlayingCurrentPlaylistSong()
{
// Arrange
var currentSong = new SongModel();
var playlistMock = new Mock <IPlaylistViewModel>();
playlistMock.Setup(x => x.CurrentSong).Returns(currentSong);
var songPlayerMock = new Mock <ISongPlayerViewModel>();
var mocker = new AutoMocker();
mocker.Use(playlistMock);
mocker.Use(songPlayerMock);
var target = mocker.CreateInstance <PlaylistPlayerViewModel>();
await target.ReversePlaying(CancellationToken.None);
playlistMock.Invocations.Clear();
songPlayerMock.Invocations.Clear();
// Act
Messenger.Default.Send(new PlayPlaylistStartingFromSongEventArgs());
// Assert
songPlayerMock.Verify(x => x.StopPlaying(), Times.Once);
songPlayerMock.Verify(x => x.Play(currentSong, It.IsAny <CancellationToken>()), Times.Once);
}
public async Task ReverseGeocodeAsync_ShouldReturnRegion_IfThereIsNoCity()
{
var mocker = new AutoMocker(MockBehavior.Strict);
mocker.Use(Options.Create(new LocationIQServiceSettings {
ApiKey = "apiKey"
}));
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://eu1.locationiq.com//v1/reverse.php?key=apiKey&lat=54&lon=27&format=json")
.Respond("application/json", @"{ ""address"": { ""region"": ""Minsk Region"" } }");
mocker.Use(mockHttp.ToHttpClient());
var service = mocker.CreateInstance <LocationIQService>();
var result = await service.ReverseGeocodeAsync(new GeoLocation
{
Lat = 54,
Lon = 27
});
result.Should().Be("Minsk Region");
}
public void WHEN_Param_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string scope, string cultureName,
string cartName, string customerId, string productId, int quantity, string paramName)
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <WishListRepository>();
var param = new AddLineItemParam
{
Scope = scope,
CultureInfo =
string.IsNullOrWhiteSpace(cultureName) ? null : CultureInfo.GetCultureInfo(cultureName),
CustomerId = string.IsNullOrWhiteSpace(customerId) ? Guid.Empty : GetRandom.Guid(),
CartName = cartName,
ProductId = productId,
VariantId = GetRandom.String(10),
Quantity = quantity
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => repository.AddLineItemAsync(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain(paramName);
}
public async Task TestGetUnmountedDrivesEnabled(string output, string[] names, string[] fullNames)
{
var configuration = new UnmountedDrivesConfiguration
{
IsEnabled = true
};
_autoMocker.Use(configuration);
_autoMocker
.Setup <IEnvironmentService, string>(m => m.NewLine)
.Returns("\n");
_autoMocker
.Setup <IProcessService, Task <string> >(m =>
m.ExecuteAndGetOutputAsync("lsblk", "--noheadings --raw -o NAME,MOUNTPOINT"))
.ReturnsAsync(output);
var service = _autoMocker.CreateInstance <LinuxUnmountedDriveService>();
await service.ReloadUnmountedDrivesAsync();
var drives = service.UnmountedDrives;
Assert.NotNull(drives);
var actualNames = drives.Select(d => d.Name).ToArray();
Assert.Equal(names, actualNames);
var actualFullNames = drives.Select(d => d.FullName).ToArray();
Assert.Equal(fullNames, actualFullNames);
}
public void It_calls_VerifyAll_on_all_objects_that_are_mocks()
{
mocker.Use <IService2>(x => x.Other == Mock.Of <IService1>());
var selfMock = mocker.CreateInstance <WithService>();
Assert.Throws(MockVerificationException, () => mocker.VerifyAll());
}
public async Task WHEN_Cart_has_no_valid_fulfillmentLocationId_SHOULD_invoke_UpdateShipment()
{
//Arrange
_container.Use(OvertureClientFactory.Create());
var sut = _container.CreateInstance <FixCartService>();
//Act
await sut.FixCartAsync(new FixCartParam
{
Cart = new ProcessedCart
{
CultureName = "en-US",
Payments = new List <Payment>
{
new Payment()
},
Shipments = new List <Shipment>
{
new Shipment()
}
}
});
//Assert
_container.Verify <ICartRepository>(r => r.UpdateShipmentAsync(It.IsNotNull <UpdateShipmentParam>()));
}
public void SetUp()
{
_container = new AutoMocker();
_container.Use(new Mock <IOrderHistoryViewModelFactory>(MockBehavior.Strict));
_container.Use(new Mock <IOrderRepository>(MockBehavior.Strict));
_container.Use(new Mock <ILookupService>(MockBehavior.Strict));
_container.Use(new Mock <IOrderUrlProvider>(MockBehavior.Strict));
_container.GetMock <ILookupService>()
.Setup(r => r.GetLookupDisplayNamesAsync(It.IsAny <GetLookupDisplayNamesParam>()))
.ReturnsAsync(new Dictionary <string, string>());
_container.GetMock <IOrderRepository>()
.Setup(r => r.GetShipmentNotesAsync(It.IsAny <GetShipmentNotesParam>()))
.ReturnsAsync(new List <Note>());
_container.GetMock <IOrderRepository>()
.Setup(r => r.GetOrderChangesAsync(It.IsAny <GetOrderChangesParam>()))
.ReturnsAsync(new List <OrderHistoryItem>());
_container.GetMock <IOrderDetailsViewModelFactory>()
.Setup(r => r.CreateViewModel(It.IsAny <CreateOrderDetailViewModelParam>()))
.Returns(new OrderDetailViewModel());
_container.GetMock <IOrderUrlProvider>()
.Setup(r => r.GetOrderDetailsBaseUrl(It.IsAny <CultureInfo>()))
.Returns(GetRandom.String(32));
_container.GetMock <ILineItemService>();
}
public void SetUp()
{
_container = new AutoMocker();
_container.Use(new Mock <ILocalizationProvider>(MockBehavior.Strict));
_container.Use(MockViewModelMapperFactory.Create(typeof(OrderDetailViewModel).Assembly));
_container.GetMock <ILocalizationProvider>()
.Setup(r => r.GetLocalizedString(It.IsAny <GetLocalizedParam>()))
.Returns(GetRandom.String(32));
_container.GetMock <ICartViewModelFactory>()
.Setup(r => r.GetOrderSummaryViewModel(It.IsAny <Overture.ServiceModel.Orders.Cart>(), It.IsAny <CultureInfo>()))
.Returns(new OrderSummaryViewModel());
_container.GetMock <ITaxViewModelFactory>()
.Setup(r => r.CreateTaxViewModels(It.IsAny <List <Tax> >(), It.IsAny <CultureInfo>()))
.Returns(new List <TaxViewModel>());
_container.GetMock <ICartViewModelFactory>()
.Setup(r => r.GetAddressViewModel(It.IsAny <Address>(), It.IsAny <CultureInfo>()))
.Returns(new AddressViewModel());
_container.GetMock <IPaymentProviderFactory>()
.Setup(r => r.ResolveProvider(It.IsAny <string>()))
.Returns(new FakePaymentProvider());
_container.GetMock <IShippingTrackingProviderFactory>()
.Setup(r => r.ResolveProvider(It.IsAny <string>()))
.Returns(new FakeShippingTrackingProvider());
}
public void It_creates_mock_objects_for_ctor_sealed_parameters_when_instances_provided()
{
mocker.Use("Hello World");
WithSealedParams instance = mocker.CreateInstance <WithSealedParams>();
Assert.AreEqual("Hello World", instance.Sealed);
}
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 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 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 TemplateType_AngularJsPrototype_Not_Found()
{
//Arrange
AutoMocker mocker = new AutoMocker();
var proxySettings = new ProxySettings();
proxySettings.Templates.Add(new TemplateEntry() { TemplateType = TemplateTypes.AngularJsModule });
mocker.Use<IProxyGeneratorFactoryManager>(new ProxyGeneratorFactoryManager(proxySettings));
var myMock = mocker.CreateInstance<AngularJsProxyBuilder>();
//Act
var generatedProxyEntries = myMock.BuildProxy(new List<ProxyControllerInfo>());
}
private static ContentFragment CreateFragment(string internalFormat)
{
var mocker = new AutoMocker();
mocker.Use<TemplateModelSelector>(mocker.CreateInstance<TemplateModelSelector>());
mocker.Use<DisplayChannelService>(mocker.CreateInstance<DisplayChannelService>());
mocker.Use<TemplateModelRepository>(mocker.CreateInstance<TemplateModelRepository>());
mocker.Use<TemplateResolver>(mocker.CreateInstance<TemplateResolver>());
mocker.Use<TemplateControlLoader>(mocker.CreateInstance<TemplateControlLoader>());
var fragment = new Mock<ContentFragment>(Mock.Of<IContentLoader>(), mocker.CreateInstance<TemplateControlLoader>(), Mock.Of<ISecuredFragmentMarkupGenerator>());
fragment.SetupGet(x => x.InternalFormat).Returns(internalFormat);
return fragment.Object;
}
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>());
}
