public void T003_GetCities_CitiesWithoutRepeats()
{
// Arrange
var advertRepo = new Mock <IGenericRepository <Advert> >();
var advertTypesRepo = new Mock <IGenericRepository <AdvertType> >();
const string cityName = "Test1";
const string expectedCityName = "Miejscowość: " + cityName;
const string expectedFirstValue = "Miejscowość: Wszystkie";
IReturnsResult <IGenericRepository <Advert> > returnsResult = advertRepo.Setup(x => x.GetSet()).Returns(new List <Advert>()
{
new Advert()
{
City = cityName
}, new Advert()
{
City = cityName
}
});
advertTypesRepo.Setup(x => x.GetSet()).Returns(new List <AdvertType>());
// Act
var advertSearchOptionService = new AdvertSearchOptionService(advertRepo.Object, advertTypesRepo.Object);
var result = advertSearchOptionService.GetCities();
// Assert
Assert.AreEqual(result.Count, 2);
Assert.AreEqual(result[0].Text, expectedFirstValue);
Assert.AreEqual(result[0].Value, String.Empty);
Assert.AreEqual(result[1].Text, expectedCityName);
Assert.AreEqual(result[1].Value, cityName);
}
public ContextMethodCallReturn(IReturnsResult <IBaseMessageContext> contextMethodCallReturnImplementation)
{
if (contextMethodCallReturnImplementation == null)
{
throw new ArgumentNullException("contextMethodCallReturnImplementation");
}
_contextMethodCallReturnImplementation = contextMethodCallReturnImplementation;
}
public MoqReturnsResultWrapper(
LambdaExpression expression,
IReturnsResult <TMock> returnsResult,
IVerifiedMock testeroidsMock)
{
this.Expression = expression;
this.wrappedReturnsResult = returnsResult;
this.TesteroidsMock = testeroidsMock;
}
/*--------------------------------------------------------------------------------------------*/
protected void SetupMockAccessToken(FabOauthAccess pResult, Action pCallback = null)
{
IReturnsResult <IOauthService> rr = MockOauth
.Setup(x => x.AccessTokenClientCredentials.Get(
MockConfig.Object.AppId,
MockConfig.Object.AppSecret,
MockConfig.Object.GetOauthRedirectUri(),
SessionType.App
))
.Returns(pResult);
if (pCallback != null)
{
rr.Callback(pCallback);
}
}
protected override void SetupVerifiableWrapper(Mock <IVerifiableWrapper> mockVerifiableWrapper, IReturnsResult <IToMock> wrappedReturn, IReturnsResult <IToMock> verifiableWrapperReturn)
{
mockVerifiableWrapper.Setup(m => m.WrapReturnsForVerification(mockedWrappedReturn)).Returns(mockedVerifiableWrapperReturn);
}
protected override void SetupCallbase(Mock <ISetup <IToMock, string> > mockWrapped, IReturnsResult <IToMock> wrappedReturn)
{
mockWrapped.Setup(m => m.CallBase()).Returns(mockedWrappedReturn);
}
public VerifiableReturnsResult(IReturnsResult <TResult> wrapped, IVerifiableWrapper verifiableWrapper) : base(wrapped, verifiableWrapper)
{
}
public IReturnsResult <TResult> WrapReturnsForVerification <TResult>(IReturnsResult <TResult> wrap)
{
return(new VerifiableReturnsResult <TResult>(wrap, this));
}
public ContextMethodCallReturn(IReturnsResult <IBaseMessageContext> contextMethodCallReturnImplementation)
{
_contextMethodCallReturnImplementation = contextMethodCallReturnImplementation ?? throw new ArgumentNullException(nameof(contextMethodCallReturnImplementation));
}
protected override void SetupCallbase(Mock <ISetupGetter <IToMock, int> > mockWrapped, IReturnsResult <IToMock> wrappedReturn)
{
mockWrapped.Setup(m => m.CallBase()).Returns(wrappedReturn);
}
protected override void SetupCallbase(Mock <IReturnsThrows <IToMock, string> > mockWrapped, IReturnsResult <IToMock> returns)
{
mockWrapped.Setup(m => m.CallBase()).Returns(returns);
}
protected void OnRequestMade(Action <HttpRequestMessage> handler, IReturnsResult <HttpMessageHandler> result) => result.Callback <HttpRequestMessage, CancellationToken>((r, c) => handler(r));
protected UnitTest()
{
HttpClient = new HttpClient(MessageHandler.Object);
MessageHandlerResult = ConfigureMessageHandlerResultSuccess(MessageHandler);
HttpRequest = new HttpRequest(RequestUrl, HttpClient);
}
