public void Promote_Should_Use_DomainObjectFactory_And_VoteRepository()
{
var user = new User {
Id = Guid.NewGuid()
};
var at = SystemTime.Now();
var fromIpAddress = "192.168.0.1";
domainObjectFactory.Setup(r => r.CreateStoryVote(_story, at, user, fromIpAddress)).Returns(new StoryVote()).Verifiable();
_story.Promote(at, user, fromIpAddress);
domainObjectFactory.Verify();
voteRepository.Verify(r => r.Add(It.IsAny <StoryVote>()), Times.AtMostOnce());
}
public void Demote_Should_Use_VoteRepository()
{
_story.User = new User {
Id = Guid.NewGuid()
};
voteRepository.Setup(r => r.FindById(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(new StoryVote()).Verifiable();
_story.Demote(SystemTime.Now(), new User {
Id = Guid.NewGuid()
});
voteRepository.Verify(r => r.Remove(It.IsAny <StoryVote>()), Times.AtMostOnce());
voteRepository.Verify();
}
public void Given_UseIdAndPassword_WhenPasswordChange_ThenPasswordChange()
{
//Arrage
var user = GetUser();
_mockUserRepository.Setup(m => m.Count(It.IsAny <Func <User, bool> >())).Returns(1);
_mockUserRepository.Setup(m => m.Get(It.IsAny <Expression <Func <User, bool> > >())).Returns(user);
_mockUserRepository.Setup(m => m.Update(user.Id.ToString(), user));
//act
_userDomain.ChangePassord(user.Id, user.Password);
//Asert
_mockUserRepository.Verify(x => x.Count(It.IsAny <Func <User, bool> >()), Times.AtMostOnce());
_mockUserRepository.Verify(x => x.Get(It.IsAny <Expression <Func <User, bool> > >()), Times.AtMostOnce());
_mockUserRepository.Verify(x => x.Update(user.Id.ToString(), user), Times.AtMostOnce());
}
public void ApplyDatabase_should_run_targeted_model_conventions()
{
var database = new EdmModel().Initialize();
var table = database.AddTable("T");
var mockConvention = new Mock <IDbConvention <EntityType> >();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[]
{
mockConvention.Object
});
conventionsConfiguration.ApplyDatabase(database);
mockConvention.Verify(c => c.Apply(table, database), Times.AtMostOnce());
}
public void Moq_AnalyzeData_SaveDataMethodShouldBeCalledBecauseTemperatureIsRight(TemperatureLevel saveDataLevel, float temperature)
{
client.Setup(i => i.GetTemperature()).Returns(temperature);
saver.Setup(d => d.SaveData(It.IsAny <float>()));
var analyzer = new GreenHouseAnalyzer(
saveDataLevel: saveDataLevel,
logMessageLevel: TemperatureLevel.All,
fakeDataSaver: saver.Object,
fakeGreenHouseClient: client.Object);
analyzer.AnalyzeData();
saver.Verify(d => d.SaveData(temperature), Times.AtMostOnce());
}
public void ThrowsIfVerifySetAtMostOnceAndMoreThanOneCall()
{
var mock = new Mock <IFoo>();
mock.Object.Value = 3;
mock.VerifySet(f => f.Value = 3, Times.AtMostOnce());
mock.Object.Value = 3;
MockException mex = Assert.Throws <MockException>(
() => mock.VerifySet(f => f.Value = 3, Times.AtMostOnce()));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
}
public void ThrowsIfVerifyReturningAtMostOnceAndMoreThanOneCall()
{
var mock = new Mock <IFoo>();
mock.Object.Execute("");
mock.Verify(foo => foo.Execute(""), Times.AtMostOnce());
mock.Object.Execute("");
MockException mex = Assert.Throws <MockException>(
() => mock.Verify(foo => foo.Execute(""), Times.AtMostOnce()));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
}
public void Create_ShouldCall_Create_From_Repository()
{
// устанавливаем параметр заглушки
// в заглушке прописываем что в репозиторий прилетит HddMetric объект
mock.Setup(repository => repository.Create(It.IsAny <HddMetric>())).Verifiable();
// выполняем действие на контроллере
var result = controller.Create(new MetricsAgent.Requests.HddMetricCreateRequest {
Time = DateTimeOffset.FromUnixTimeSeconds(2), Value = 50
});
// проверяем заглушку на то, что пока работал контроллер
// действительно вызвался метод Create репозитория с нужным типом объекта в параметре
mock.Verify(repository => repository.Create(It.IsAny <HddMetric>()), Times.AtMostOnce());
}
public void AddComment_Should_Use_IDomainObjectFactory_And_ICommentRepository()
{
var repository = SetupResolve <ICommentRepository>();
var domFactory = SetupResolve <IDomainObjectFactory>();
var now = SystemTime.Now();
domFactory.Setup(f => f.CreateComment(_story.Object, "dummy content", now, It.IsAny <IUser>(), "127.0.0.1")).Returns(
It.IsAny <IComment>()).Verifiable();
_story.Object.AddComment("dummy content", now, new Mock <IUser>().Object, "127.0.0.1");
domFactory.Verify();
repository.Verify(r => r.Add(It.IsAny <IComment>()), Times.AtMostOnce());
}
public void AddVote_Should_Use_IDomainObjectFactory_And_IVoteRepository()
{
var repository = SetupResolve <IVoteRepository>();
var domFactory = SetupResolve <IDomainObjectFactory>();
var now = SystemTime.Now();
domFactory.Setup(f => f.CreateStoryVote(_story.Object, now, It.IsAny <IUser>(), "127.0.0.1")).Returns(
It.IsAny <IVote>()).Verifiable();
_story.Object.AddVote(now, new Mock <IUser>().Object, "127.0.0.1");
domFactory.Verify();
repository.Verify(r => r.Add(It.IsAny <IVote>()), Times.AtMostOnce());
}
public void InstantiateFrameworkProviderCachesResults()
{
var providerMock = new Mock <IFrameworkProvider>();
var serviceLocatorMock = new Mock <IServiceLocator>();
serviceLocatorMock.Setup(sl => sl.GetInstance <IFrameworkProvider>()).Returns(providerMock.Object);
var factory = new Factory(serviceLocatorMock.Object);
var first = factory.InstantiateFrameworkProvider();
var second = factory.InstantiateFrameworkProvider();
Assert.Equal(providerMock.Object, first);
Assert.Equal(providerMock.Object, second);
serviceLocatorMock.Verify(sl => sl.GetInstance <IFrameworkProvider>(), Times.AtMostOnce());
}
public void RejectedWithZeroTotal()
{
GivenSalesOrderAndCardInfo();
moqCardValidator.Setup(m => m.Validate(It.IsAny <CardInfo>())).Returns(true);
moqMerchantServicesAuthorizer.Setup(m => m.Authorize(It.IsAny <decimal>(), It.IsAny <CardInfo>())).Returns((string)null);
salesOrder.SalesOrderItems.Clear();
salesOrder.Total = 0;
string authorizationCode = salesOrderManager.CompletePurchase(salesOrder, cardInfo);
moqCardValidator.Verify(m => m.Validate(cardInfo), Times.AtMostOnce());
moqSalesOrdersSet.Verify(m => m.Update(salesOrder), Times.Never());
Assert.Null(authorizationCode);
}
public void ApplyModel_should_run_targeted_model_conventions()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
var mockConvention = new Mock <IEdmConvention <EntityType> >();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[]
{
mockConvention.Object
});
conventionsConfiguration.ApplyModel(model);
mockConvention.Verify(c => c.Apply(entityType, model), Times.AtMostOnce());
}
public void GetAllAgentsCheckRequestCreate()
{
//Arrange
var mockLogger = new Mock <ILogger <AgentsController> >();
var mock = new Mock <IAgentsRepository>();
mock.Setup(a => a.GetAll()).Returns(new List <AgentModel>()).Verifiable();
var controller = new AgentsController(mock.Object, mockLogger.Object);
//Act
var result = controller.GetAllAgents();
//Assert
mock.Verify(repository => repository.GetAll(), Times.AtMostOnce());
mockLogger.Verify();
}
public void DeleteAllOnSubmit_Should_Call_DeleteOnSubmit()
{
var stories = new List <Story> {
new Story(), new Story(), new Story(), new Story()
};
_database.Object.InsertAllOnSubmit(stories);
_database.Object.DeleteAllOnSubmit(stories.AsQueryable());
foreach (var story in stories)
{
Story entity = story;
_database.Verify(e => e.DeleteOnSubmit(entity), Times.AtMostOnce());
}
}
public async Task SubmitOrder_Should_ReturnSuccess_WithValidOrder()
{
//Arrange
options.Setup(x => x.Value).Returns(apiSettings);
HttpClient httpClient = new HttpClient(httpMessageHandlerMock.Object);
orderService = new OrderService(httpClient, options.Object, logger.Object);
httpMessageHandlerMock.Protected().Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
.ReturnsAsync(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject("Order Submitted"), Encoding.UTF8, "application/json")
})
.Verifiable();
var order = new Order
{
LineItems = new List <OrderItem> {
new OrderItem {
ProductId = "123", Quantity = 1
}
},
CustomerEmail = "*****@*****.**",
CustomerName = "testName"
};
//Act
var result = await orderService.SubmitOrder(order);
// Assert
Assert.IsNotNull(result);
Assert.AreEqual("\"Order Submitted\"", result);
httpMessageHandlerMock.Protected().Verify(
"SendAsync",
Times.AtMostOnce(), // verify number of times SendAsync is called
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Post && // verify the HttpMethod for request is GET
req.RequestUri.ToString() == apiSettings.BaseUrl && // verify the RequestUri is as expected
req.Headers.GetValues("Accept").FirstOrDefault() == "application/json" && //Verify Accept header
req.Headers.GetValues("tracking-id").FirstOrDefault() != null //Verify tracking-id header is added
),
ItExpr.IsAny <CancellationToken>()
);
}
public void ReuseExistingLogger()
{
var logger = new NullLogger();
var locatorMock = new Mock <IServiceLocator>();
locatorMock.Setup(l => l.GetInstance <ILogger>()).Returns(logger);
var factory = new Factory(locatorMock.Object);
var first = factory.InstantiateLogger();
var second = factory.InstantiateLogger();
Assert.Equal(logger, first);
Assert.Equal(logger, second);
locatorMock.Verify(l => l.GetInstance <ILogger>(), Times.AtMostOnce());
}
//
// You can use the following additional attributes as you write your tests:
//
// Use ClassInitialize to run code before running the first test in the class
// [ClassInitialize()]
// public static void MyClassInitialize(TestContext testContext) { }
//
// Use ClassCleanup to run code after all tests in a class have run
// [ClassCleanup()]
// public static void MyClassCleanup() { }
//
// Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize() { }
//
// Use TestCleanup to run code after each test has run
// [TestCleanup()]
// public void MyTestCleanup() { }
//
#endregion
/// <summary>
/// Test that SaveMessage makes the necessary save method to the backend repository
/// </summary>
/// <returns></returns>
//[TestMethod]
public async Task V1_SaveMessage_SavesData_ToRepository()
{
//arrange
var mockRepository = new Mock <IHelloWorldRepository>();
mockRepository.Setup(m => m.SaveMessageAsync(It.IsAny <string>())).Returns(Task.FromResult(false));
IHelloWorldDbApi api = new HelloWorldDbApiV1(mockRepository.Object);
string msg = "Hello World";
//act
await api.SaveMessageAsync(msg);
//assert a call to the repository was made.
mockRepository.Verify(mock => mock.SaveMessageAsync(msg), Times.AtMostOnce());
}
public void Create_ShouldCall_Create_From_Repository()
{
// устанавливаем параметр заглушки
// в заглушке прописываем что в репозиторий прилетит Metric объект
_mock.Setup(repository =>
repository.Create(It.IsAny <CpuMetric>())).Verifiable();
// выполняем действие на контроллере
var result = _controller.Create(new
MetricsAgent.Requests.CpuMetricCreateRequest
{
Time = DateTimeOffset.FromUnixTimeSeconds(1),
Value = 50
});
_mock.Verify(repository => repository.Create(It.IsAny <CpuMetric>()), Times.AtMostOnce());
}
public void ShouldOnlyRunPotentiallyExpensiveChecksOnceIfSuccessful()
{
// When the waiter waits for a check which is already true
var checkProvider = new Mock <IProvideChecks>();
checkProvider.Setup(cp => cp.Check()).Returns(true);
new Waiter().WaitFor(new Panel(AutomationElement.RootElement, "Desktop"),
(src, e) => checkProvider.Object.Check(),
new TimeSpan(0, 0, 5),
(ex) => Assert.Fail("Could not handle guaranteed event"),
new List <AutomationEventWrapper>());
// Then it should only have run once
checkProvider.Verify(cp => cp.Check(), Times.AtMostOnce());
}
public void ThrowsIfVerifyVoidAtMostOnceAndMoreThanOneCall()
{
var mock = new Mock <IFoo>();
mock.Object.Submit();
mock.Verify(foo => foo.Submit(), Times.AtMostOnce());
mock.Object.Submit();
var mex = Assert.Throws <MockException>(() =>
mock.Verify(foo => foo.Submit(), Times.AtMostOnce()));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
Assert.Contains("Expected invocation on the mock at most once, but was 2 times: foo => foo.Submit()", mex.Message);
}
public void ImportSameCoursesTwice()
{
var course = GetCourses(1).First();
var result1 = subject.SaveCourses(new List <Course> {
course
}).Result;
AssertOkay(result1);
locationRequesterMock.Verify(x => x.RequestLocations(), Times.AtMostOnce());
var course2 = GetCourses(1).First();
var result2 = subject.SaveCourses(new List <Course> {
course2
}).Result;
AssertOkay(result2);
locationRequesterMock.Verify(x => x.RequestLocations(), Times.Exactly(2));
var resultingCourses = context.GetCoursesWithProviderSubjectsRouteAndCampuses().ToList();
var resultingProviders = context.Providers.ToList();
resultingCourses.Count().Should().Be(1);
var savedCourse = resultingCourses.First();
savedCourse.Campuses.Count().Should().Be(course.Campuses.Count());
savedCourse.DescriptionSections.Count().Should().Be(course.DescriptionSections.Count());
resultingCourses.SelectMany(x => x.DescriptionSections).Count().Should().Be(course.DescriptionSections.Count());
// deduplicated
var courses = new List <Course> {
course, course2
};
resultingProviders.Count.Should().Be(1);
context.Routes.Count().Should().Be(1);
context.Subjects.Count().Should().Be(1);
var expectedLocations = GetExpectedLocations(courses);
context.Locations.Count().Should().Be(expectedLocations.Count());
context.Campuses.Count().Should().Be(4); //definately right
// non-deduplicated
context.Contacts.Count().Should().Be(2); //probably wrong
context.CourseSubjects.Count().Should().Be(1);
}
public void CanCreateOrder()
{
// var db = new Mock<ShoppingDb>();
var customerRepository = new Mock <IRepository <Customer> >();
var orderRepository = new Mock <IRepository <Order> >();
var productRepository = new Mock <IRepository <Product> >();
// var orderController = new OrderController(orderRepository.Object,
// productRepository.Object);
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(uow => uow.CustomerRepository).Returns(() => customerRepository.Object);
unitOfWork.Setup(uow => uow.OrderRepository).Returns(() => orderRepository.Object);
unitOfWork.Setup(uow => uow.ProductRepository).Returns(() => productRepository.Object);
var orderController = new OrderController(unitOfWork.Object);
var createOrder = new CreateOrderModel
{
Customer = new CustomerModel
{
Name = "Tom Randles",
ShippingAddress = "Knocknacarra, Galway",
City = "Galway",
Country = "Ireland"
},
LineItems = new[]
{
new LineItemModel {
ProductId = Guid.NewGuid(), Quantity = 4
},
new LineItemModel {
ProductId = Guid.NewGuid(), Quantity = 2
}
}
};
// Create order
orderController.Create(createOrder);
// Verify that the order repository Add function was called once.
orderRepository.Verify(repository => repository.Add(It.IsAny <Order>()),
Times.AtMostOnce());
}
public void AddCommentToEncounterEncountersController()
{
var encounterServices = new Mock <IEncounterSimpleServices>();
var encounterQueryServices = new Mock <IEncounterQueryServices>();
var fixtureGeneratorServices = new Mock <IFixtureServices>();
ILoginServices loginServices = new LoginServicesMock(santiago);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
EncounterDTO encounter = new EncounterDTO()
{
Id = IntToGuid(4), SportName = "Futbol", TeamIds = new List <string>()
{
"Peñarol", "Nacional"
}
};
IEnumerable <EncounterDTO> encounters = new List <EncounterDTO>()
{
encounter
};
encounterServices.Setup(e => e.GetAllEncounters()).Returns(encounters);
var controller = new EncountersController(loginServices, encounterServices.Object, new LoggerStub(), encounterQueryServices.Object, fixtureGeneratorServices.Object, teamServices.Object)
{
ControllerContext = controllerContext,
};
var comment = new CommentModelIn()
{
Message = "This is a test comment in a mock!"
};
var obtainedResult = controller.AddEncounterComment(4 + "", comment) as OkResult;
encounterServices.Verify(m => m.GetAllEncounters(), Times.AtMostOnce());
Assert.IsNotNull(obtainedResult);
Assert.AreEqual(200, obtainedResult.StatusCode);
}
public void ThrowsIfVerifyVoidAtMostOnceAndMoreThanOneCall()
{
var mock = new Mock <IFoo>();
mock.Object.Submit();
mock.Verify(foo => foo.Submit(), Times.AtMostOnce());
mock.Object.Submit();
var mex = AssertHelper.Throws <MockException>(() =>
mock.Verify(foo => foo.Submit(), Times.AtMostOnce()));
Assert.AreEqual(MockException.ExceptionReason.VerificationFailed, mex.Reason);
Assert.IsTrue(mex.Message.StartsWith(
"\r\nExpected invocation on the mock at most once, but was 2 times: foo => foo.Submit()"));
}
public void WhenCallingStartAndMessageAddedThenImmediatelyStopShouldNotCallPostOnHttpClient()
{
var message = this.CreateMessage();
this.ForwardService.Start();
Thread.Sleep(50);
this.PersistentStore.Add(message);
this.ForwardService.Stop();
Thread.Sleep(200);
this.PersistentStore.Add(this.CreateMessage());
Thread.Sleep(200);
Assert.NotNull(this.PersistentStore.Get());
this.HttpClient.Verify(c => c.Post(It.IsAny <IMessage>()), Times.AtMostOnce());
}
public void GetCardsPassed()
{
// Arrange
var mock = new Mock <IBankRepository>();
var mockCards = new FakeDataGenerator(_businessLogicService).GenerateFakeCards();
mock.Setup(r => r.GetCards()).Returns(mockCards);
var controller = new CardsController(mock.Object, _cardService, _businessLogicService);
// Test
var cards = controller.Get();
// Assert
mock.Verify(r => r.GetCards(), Times.AtMostOnce());
Assert.Equal(3, cards.Count());
}
public void Should_Create_First_Generation_When_Initialising_World()
{
// Arrange
var presenter = new Mock <IDisplayPresenter>();
var quitManager = new Mock <IQuitManager>();
var saveStateManager = new Mock <ISaveStateManager>();
var worldGenerator = new Mock <IWorldGenerator>();
worldGenerator.Setup(o => o.CreateFirstGeneration(It.IsAny <string>())).Returns(It.IsAny <World>());
var controller = new GameController(presenter.Object, quitManager.Object, saveStateManager.Object, worldGenerator.Object);
// Act
var world = controller.InitialiseFirstWorld(new[] { "TestFiles/ValidInitialState.json" });
// Assert
worldGenerator.Verify(o => o.CreateFirstGeneration(It.IsAny <string>()), Times.AtMostOnce());
}
public void Bruker_Er_I_DB_OK()
{
var _mock = new Mock <InterfaceDbTBruker>();
var Loggin = new LogInn()
{
Brukernavn = "*****@*****.**",
Passord = "Password123",
};
_mock.Setup(x => x.BrukerIdb(Loggin)).Returns(true);
_mock.Verify(framework => framework.BrukerIdb(Loggin), Times.AtMostOnce());
InterfaceDbTBruker lovable = _mock.Object;
var actual = lovable.BrukerIdb(Loggin);
Assert.AreEqual(true, actual);
}
public void Play_2_Sides_Winner_Determined()
{
//Arrange
target = new PlayTournament(playMatches);
var winner = new Mock <ISide>();
playMatch.Setup <ISide>(m => m.Play()).Returns(winner.Object);
//Act
var result = target.Play();
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(winner.Object, result);
playMatch.Verify(m => m.Play(), Times.AtMostOnce());
Assert.AreEqual(1, target.GetMatchScores().Count());
}
