public void TestInitialize()
{
_fakeBuilder = new FakeClassBuilder <RateLimitCacheManager>();
_fakeRateLimitCache = _fakeBuilder.GetFake <IRateLimitCache>();
_fakeRateLimitHelper = _fakeBuilder.GetFake <IRateLimitHelper>();
_fakeTwitterRequester = _fakeBuilder.GetFake <ITwitterRequester>();
_fakeHelpQueryGenerator = _fakeBuilder.GetFake <IHelpQueryGenerator>();
_fakeJsonObjectConverter = _fakeBuilder.GetFake <IJsonObjectConverter>();
_fakeCredentialsAccessor = _fakeBuilder.GetFake <ICredentialsAccessor>();
_fakeTwitterQueryFactory = _fakeBuilder.GetFake <ITwitterQueryFactory>();
InitializeData();
_fakeRateLimitHelper.CallsTo(x => x.GetTokenRateLimitFromQuery(TEST_QUERY, _tokenRateLimits)).Returns(_tokenRateLimit);
_fakeRateLimitCache.CallsTo(x => x.GetTokenRateLimits(_credentials)).Returns(_tokenRateLimits);
_fakeRateLimitCache.CallsTo(x => x.RefreshEntry(_credentials, _tokenRateLimits)).Invokes(() =>
{
_fakeRateLimitCache.CallsTo(x => x.GetTokenRateLimits(_credentials)).Returns(_refreshedTokenRateLimits);
_fakeRateLimitHelper.CallsTo(x => x.GetTokenRateLimitFromQuery(TEST_QUERY, _refreshedTokenRateLimits)).Returns(_refreshedTokenRateLimit);
});
_fakeCredentialsAccessor.SetupPassThrough <ITokenRateLimits>();
_fakeHelpQueryGenerator.CallsTo(x => x.GetCredentialsLimitsQuery()).Returns(TEST_QUERY);
_fakeTwitterRequester.CallsTo(x => x.ExecuteQuery(_twitterQuery, null)).Returns(TEST_QUERY);
_fakeJsonObjectConverter.CallsTo(x => x.DeserializeObject <ITokenRateLimits>(TEST_QUERY, It.IsAny <JsonConverter[]>())).ReturnsNextFromSequence(_tokenRateLimits, _tokenRateLimits2);
_fakeTwitterQueryFactory.CallsTo(x => x.Create(TEST_QUERY, It.IsAny <HttpMethod>(), It.IsAny <ITwitterCredentials>())).Returns(_twitterQuery);
}
private ITweetDTO GenerateTweet(
bool canTweetBePublished,
bool hasPlaceIdParameter,
bool hasCoordinatesParameter)
{
var tweet = A.Fake <ITweetDTO>();
var tweetId = TestHelper.GenerateRandomLong();
var text = TestHelper.GenerateString();
var placeId = TestHelper.GenerateString();
var coordinates = A.Fake <ICoordinates>();
tweet.CallsTo(x => x.Text).Returns(text);
tweet.CallsTo(x => x.Id).Returns(tweetId);
tweet.CallsTo(x => x.PlaceId).Returns(placeId);
tweet.CallsTo(x => x.Coordinates).Returns(coordinates);
_expectedTweetParameter = TestHelper.GenerateString();
_fakeTwitterStringFormatter.CallsTo(x => x.TwitterEncode(text)).Returns(_expectedTweetParameter);
_expectedPlaceIdParameter = hasPlaceIdParameter ? TestHelper.GenerateString() : null;
_fakeGeoQueryGenerator.CallsTo(x => x.GeneratePlaceIdParameter(tweet.PlaceId)).Returns(_expectedPlaceIdParameter);
_expectedCoordinatesParameter = hasCoordinatesParameter ? TestHelper.GenerateString() : null;
_fakeGeoQueryGenerator.CallsTo(x => x.GenerateGeoParameter(coordinates)).Returns(_expectedCoordinatesParameter);
_fakeTweetQueryValidator.CallsTo(x => x.CanTweetDTOBePublished(tweet)).Returns(canTweetBePublished);
return(tweet);
}
public void PublishMessage_ExpectedQuery()
{
var text = TestHelper.GenerateString();
var formattedText = TestHelper.GenerateString();
var user = A.Fake <IUserIdentifier>();
var parameter = A.Fake <IPublishMessageParameters>();
parameter.CallsTo(x => x.Text).Returns(text);
parameter.CallsTo(x => x.Recipient).Returns(user);
_fakeTwitterStringFormatter.CallsTo(x => x.TwitterEncode(text)).Returns(formattedText);
// Arrange
var queryGenerator = CreateMessageQueryGenerator();
var expectedIdentifierParameter = Guid.NewGuid().ToString();
var expectedResult = string.Format(Resources.Message_NewMessage, formattedText, expectedIdentifierParameter);
_fakeUserQueryParameterGenerator.ArrangeGenerateIdOrScreenNameParameter(expectedIdentifierParameter);
// Act
var result = queryGenerator.GetPublishMessageQuery(parameter);
// Assert
Assert.AreEqual(result, expectedResult);
_fakeMessageQueryValidator.CallsTo(x => x.ThrowIfMessageCannotBePublished(parameter)).MustHaveHappened();
}
public void On_FileDrop_format_and_one_file_with_directory_has_text_with_files_count_and_filename_and_folder()
{
// Arrange
var file = "c:\\file1.ext";
var folder = "c:\\folder";
var data = new DataObject(DataFormats.FileDrop, new string[] { file, folder });
var viewModel = new BuferViewModel
{
Clip = data
};
var fileStorage = new Fake <IFileStorage>();
fileStorage.CallsTo(s => s.GetFileAttributes(file)).Returns(FileAttributes.Normal);
fileStorage.CallsTo(s => s.GetFileDirectory(file)).Returns("c:\\");
fileStorage.CallsTo(s => s.GetFileName(file)).Returns("file1.ext");
fileStorage.CallsTo(s => s.GetFileName(folder)).Returns("folder");
fileStorage.CallsTo(s => s.GetFileAttributes(folder)).Returns(FileAttributes.Directory);
var sut = new DataObjectHandler(
A.Fake <IClipboardBuferService>(),
A.Fake <IProgramSettingsGetter>(),
fileStorage.FakedObject);
// Act
sut.TryHandleDataObject(viewModel);
// Assert
Assert.AreEqual("c:\\" + Environment.NewLine + Environment.NewLine + "file1.ext" + Environment.NewLine + "folder\\", viewModel.Representation);
}
private void InitData()
{
_authenticatedUserCredentials = A.Fake <ITwitterCredentials>();
_fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_authenticatedUserCredentials);
_authenticatedUser = CreateAuthenticatedUser();
_currentCredentials = A.Fake <ITwitterCredentials>();
_fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_currentCredentials);
}
private void InitData()
{
_loggedUserCredentials = A.Fake <IOAuthCredentials>();
_fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_loggedUserCredentials);
_loggedUser = CreateLoggedUser();
_currentCredentials = A.Fake <IOAuthCredentials>();
_fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_currentCredentials);
}
public void WaitForCurrentCredentialsRateLimit_AwaitForRateLimitCheckerTimeToWait()
{
// Arrange
var rateLimitAwaiter = CreateRateLimitAwaiter();
// Act
rateLimitAwaiter.WaitForCurrentCredentialsRateLimit(TEST_QUERY);
// Assert
_fakeThreadHelper.CallsTo(x => x.Sleep(TIME_TO_WAIT)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task BlockUser_ReturnsAccountClientTask()
{
// Arrange
var user = A.Fake <IUserIdentifier>();
// Act
await _authenticatedUser.BlockUser(user);
// Assert
_usersClient.CallsTo(x => x.BlockUser(user)).MustHaveHappened();
}
private void InitData()
{
_twitterClient = new Fake <ITwitterClient>();
_tweetsClient = new Fake <ITweetsClient>();
_usersClient = new Fake <IUsersClient>();
_twitterClient.CallsTo(x => x.Tweets).Returns(_tweetsClient.FakedObject);
_twitterClient.CallsTo(x => x.Users).Returns(_usersClient.FakedObject);
_authenticatedUser = _fakeBuilder.GenerateClass();
_authenticatedUser.Client = _twitterClient.FakedObject;
}
public void QueryExecuted_QueryCannotBeFound_DoesNothing()
{
// Arrange
var cacheUpdater = CreateRateLimitUpdater();
_fakeRateLimitCacheManager.CallsTo(x => x.GetQueryRateLimit(TEST_QUERY, _credentials)).Returns(null);
// Act
cacheUpdater.QueryExecuted(TEST_QUERY);
// Assert
Assert.AreEqual(_endpointRateLimit.Remaining, 5);
}
public void GetHomeTimeline_FromHomeTimelineRequest_ReturnsExpectedResult()
{
// Arrange
var queryExecutor = CreateTimelineQueryExecutor();
_fakeTimelineQueryGenerator.CallsTo(x => x.GetHomeTimelineQuery(_fakeHomeTimelineParameters)).Returns(_expectedQuery);
// Act
var result = queryExecutor.GetHomeTimeline(_fakeHomeTimelineParameters);
// Assert
Assert.AreEqual(result, _expectedResult);
}
public void GetSearchTweetQuery_WithTweetSearchParameter_SearchParameterIsInvalid_ReturnsNull()
{
// Arrange
var searchQueryGenerator = CreateSearchQueryGenerator();
_fakeSearchQueryValidator.CallsTo(x => x.IsSearchParameterValid(_tweetSearchParameters)).Returns(false);
// Act
var result = searchQueryGenerator.GetSearchTweetsQuery(_tweetSearchParameters);
// Assert
Assert.IsNull(result);
}
public void SearchTweet_BasedOnQuery_ReturnsTwitterAccessorStatuses()
{
// Arrange
var queryExecutor = CreateSearchQueryExecutor();
_fakeSearchQueryGenerator.CallsTo(x => x.GetSearchTweetsQuery(_tweetSearchParameter)).Returns(_httpQuery);
_fakeTwitterAccessor.ArrangeExecuteGETQuery(_httpQuery, _searchResultDTO);
// Act
var result = queryExecutor.SearchTweets(_searchQuery);
// Assert
Assert.IsTrue(result.ContainsAll(_tweetDTOs));
}
public async Task test_GetAllEmployees()
{
_fakeRepo.CallsTo(r => r.GetAllEmployees()).WithAnyArguments().Returns(new List <EmployeeEntity>()
{
new EmployeeEntity()
{
Id = 1, Name = "user1", Department = "dept1"
}
});
var result = await _queriesService.GetAllEmployees();
_fakeRepo.CallsTo(r => r.GetAllEmployees()).WithAnyArguments().MustHaveHappened();
Assert.True(result?.Count() == 1);
}
public void GetPlaceTrendsAt_WithLocationId_ReturnsQueryExecutor()
{
// Arrange
var controller = CreateTrendsController();
var locationId = TestHelper.GenerateRandomLong();
var expectedResult = A.Fake <IPlaceTrends>();
_fakeTrendsQueryExecutor.CallsTo(x => x.GetPlaceTrendsAt(locationId)).Returns(expectedResult);
// Act
var result = controller.GetPlaceTrendsAt(locationId);
// Assert
Assert.AreEqual(result, expectedResult);
}
public async Task test_GetAllEmployees()
{
_fakeQueries.CallsTo(r => r.GetAllEmployees()).WithAnyArguments().Returns(new List <Employee>()
{
new Employee()
{
Id = 1, Name = "user1", Department = "dept1"
}
});
var result = await _controller.Get();
_fakeQueries.CallsTo(r => r.GetAllEmployees()).WithAnyArguments().MustHaveHappened();
Assert.True(result?.Value.Count() == 1);
}
public void GetSavedSearches_ReturnsTwitterAccessorResult()
{
// Arrange
var controller = CreateSavedSearchQueryExecutor();
string query = TestHelper.GenerateString();
IEnumerable <ISavedSearchDTO> expectedResult = new List <ISavedSearchDTO>();
_fakeSavedSearchQueryGenerator.CallsTo(x => x.GetSavedSearchesQuery()).Returns(query);
_fakeTwitterAccessor.ArrangeExecuteGETQuery(query, expectedResult);
// Act
var result = controller.GetSavedSearches();
// Assert
Assert.AreEqual(result, expectedResult);
}
public ExpressionSqlGeneratorTests()
{
_provider.CallsTo(d => d.GetSql(A <MethodCallExpression> ._, A <IGenerateSqlFromExpressions> ._))
.ReturnsLazily(x => TestDbProviderExpression.Instance.GetSql(x.GetArgument <MethodCallExpression>(0),
x.GetArgument <IGenerateSqlFromExpressions>(1)));
_sut = Setup.CreateExpressionSqlGenerator(_provider.FakedObject);
}
public void GetSavedSearches_ReturnsQueryExecutor()
{
// Arrange
var controller = CreateSavedSearchController();
IEnumerable <ISavedSearchDTO> expectedDTOResult = new List <ISavedSearchDTO>();
IEnumerable <ISavedSearch> expectedResult = new List <ISavedSearch>();
_fakeSavedSearchQueryExecutor.CallsTo(x => x.GetSavedSearches()).Returns(expectedDTOResult);
_fakeSavedSearchFactory.CallsTo(x => x.GenerateSavedSearchesFromDTOs(expectedDTOResult)).Returns(expectedResult);
// Act
var result = controller.GetSavedSearches();
// Assert
Assert.AreEqual(result, expectedResult);
}
protected DbProviderFactory GetDbProviderFactoryFake()
{
var idbDataReaderFake = new Fake <DbDataReader>(a => a.CallsBaseMethods());
var idCommand = new Fake <DbCommand>(a => a.CallsBaseMethods());
idCommand.CallsTo(a => a.ExecuteScalar()).Returns(new { id = 1, idpessoa = 1, cpf = "5456647896" });
idCommand.CallsTo(a => a.ExecuteNonQuery()).Returns(2);
//idCommand.CallsTo(a => a.ExecuteDbDataReader(A<CommandBehavior>.Ignored)).ReturnsLazily(() => GetReaderFake());
var dbProviderFake = new Fake <DbProviderFactory>(a => DbProviderFactories.GetFactory("Npgsql"));
dbProviderFake.CallsTo(a => a.CreateCommand()).Returns(idCommand.FakedObject);
return(dbProviderFake.FakedObject);
}
public void RightChainShouldCallAllMethods()
{
var first = new Fake <Func <Either <int, string[]> > >();
first.CallsTo(x => x()).Returns(Either.Right <int, string[]>(1_000_000));
var second = new Fake <Func <Either <int, string[]> > >();
second.CallsTo(x => x()).Returns(Either.Right <int, string[]>(100_000));
var third = new Fake <Func <Either <int, string[]> > >();
third.CallsTo(x => x()).Returns(Either.Right <int, string[]>(10_000));
var chain = new Queue <Func <Either <int, string[]> > >();
chain.Enqueue(first.FakedObject);
chain.Enqueue(second.FakedObject);
chain.Enqueue(third.FakedObject);
var result = Execute(chain);
first.RecordedCalls.Count().Should().Be(1);
second.RecordedCalls.Count().Should().Be(1);
third.RecordedCalls.Count().Should().Be(1);
}
public void MixedChainShouldStopCallsPartwayThrough()
{
var first = new Fake <Func <Either <int, string[]> > >();
first.CallsTo(x => x()).Returns(Either.Right <int, string[]>(1_000_000));
var second = new Fake <Func <Either <int, string[]> > >();
second.CallsTo(x => x()).Returns(Either.Left <int, string[]>(new string[0]));
var third = new Fake <Func <Either <int, string[]> > >();
third.CallsTo(x => x()).Returns(Either.Right <int, string[]>(100_000));
var chain = new Queue <Func <Either <int, string[]> > >();
chain.Enqueue(first.FakedObject);
chain.Enqueue(second.FakedObject);
chain.Enqueue(third.FakedObject);
var result = Execute(chain);
first.RecordedCalls.Count().Should().Be(1);
second.RecordedCalls.Count().Should().Be(1);
third.RecordedCalls.Count().Should().Be(0);
}
public void OpenServiceCallsUnderlyingApi(Fake <IAdvApi32> advApi32, int serviceControlManagerHandleValue, int serviceHandleValue,
string serviceName)
{
advApi32.CallsTo(_ => _.OpenService(A <IntPtr> ._, A <string> ._, A <ScmAccess> ._))
.Returns(new IntPtr(serviceHandleValue));
var sut = new ServiceConnection(advApi32.FakedObject);
var connectionHandle = new ConnectionHandle {
ServiceManagerHandle = new IntPtr(serviceControlManagerHandleValue)
};
sut.Open(connectionHandle, serviceName);
advApi32.CallsTo(_ => _.OpenService(A <IntPtr> ._, A <string> ._, A <ScmAccess> ._)).MustHaveHappened();
}
public void GetCreateFriendshipWithQuery_WithValidUserDTO_ReturnsIdQuery()
{
// Arrange
var queryGenerator = CreateFrienshipQueryGenerator();
var fakeUserDTO = CreateUserDTO(true);
// Act
var query = queryGenerator.GetCreateFriendshipWithQuery(fakeUserDTO);
// Assert
string expectedUserIdParameter = UserQueryGeneratorHelper.GenerateParameterExpectedResult(fakeUserDTO);
Assert.AreEqual(query, string.Format(Resources.Friendship_Create, expectedUserIdParameter));
_fakeUserQueryValidator.CallsTo(x => x.ThrowIfUserCannotBeIdentified(fakeUserDTO)).MustHaveHappened();
}
public void WriteLockCallsUnderlyingAPI(Fake <IAdvApi32> advApi32, int serviceControlManagerHandlerValue,
int serviceDatabaseLockHandleValue)
{
advApi32.CallsTo(_ => _.AquireServiceDatabaseLock(A <IntPtr> ._))
.Returns(new IntPtr(serviceDatabaseLockHandleValue));
var sut = new ServiceDatabaseConnection(advApi32.FakedObject);
var connectionHandle = new ConnectionHandle {
ServiceManagerHandle = new IntPtr(serviceControlManagerHandlerValue)
};
sut.WriteLock(connectionHandle);
advApi32.CallsTo(_ => _.AquireServiceDatabaseLock(A <IntPtr> ._)).MustHaveHappened();
}
public void FavouriteTweet_WithTweetDTO_ThrowTwitterException_WithCode139_ReturnsFalse()
{
// Arrange
var queryExecutor = CreateTweetQueryExecutor();
var tweetDTO = A.Fake <ITweetDTO>();
var query = TestHelper.GenerateString();
_fakeTweetQueryGenerator.CallsTo(x => x.GetFavouriteTweetQuery(tweetDTO)).Returns(query);
_fakeTwitterAccessor.CallsTo(x => x.ExecutePOSTQuery(query)).Throws(_fake139TwitterException);
// Act
var result = queryExecutor.FavouriteTweet(tweetDTO);
// Assert
Assert.IsFalse(result);
}
public async Task test_AddEmployee()
{
_fakeRepo.CallsTo(r => r.AddEmployee(new EmployeeEntity())).WithAnyArguments().Returns(true);
var result = await _commandService.AddEmployee(new Employee());
_fakeRepo.CallsTo(r => r.AddEmployee(new EmployeeEntity())).WithAnyArguments().MustHaveHappened();
Assert.True(result);
}
public async Task test_AddEmployee()
{
_fakeCommands.CallsTo(r => r.AddEmployee(new Employee())).WithAnyArguments().Returns(true);
var result = await _controller.AddEmployee(new Employee());
_fakeCommands.CallsTo(r => r.AddEmployee(new Employee())).WithAnyArguments().MustHaveHappened();
Assert.True(result?.Value);
}
public void SearchTweets_WithSearchQuery_ReturnsQueryExecutorDTOTransformed()
{
// Arrange
var controller = CreateSearchController();
var searchQuery = TestHelper.GenerateString();
var searchDTOResult = new List <ITweetDTO>();
var searchResult = new List <ITweet>();
_fakeSearchQueryExecutor.CallsTo(x => x.SearchTweets(searchQuery)).Returns(searchDTOResult);
_fakeTweetFactory.CallsTo(x => x.GenerateTweetsFromDTO(searchDTOResult)).Returns(searchResult);
// Act
var result = controller.SearchTweets(searchQuery);
// Assert
Assert.AreEqual(result, searchResult);
}
public void GetPlaceTrendsAt_WithLocationId_ReturnsFirstObjectFromTheResults()
{
// Arrange
var queryExecutor = CreateTrendsJsonController();
var query = TestHelper.GenerateString();
var locationId = TestHelper.GenerateRandomLong();
var expectedResult = TestHelper.GenerateString();
_fakeTrendsQueryGenerator.CallsTo(x => x.GetPlaceTrendsAtQuery(locationId)).Returns(query);
_fakeTwitterAccessor.ArrangeExecuteJsonGETQuery(query, expectedResult);
// Act
var result = queryExecutor.GetPlaceTrendsAt(locationId);
// Assert
Assert.AreEqual(result, expectedResult);
}
public void Create_a_fake_object_that_has_methods_for_configuring_the_faked_instance()
{
var fake = new Fake<IWidgetFactory>();
// Calls can be configured directly:
fake.CallsTo(x => x.Create()).Returns(new Fake<IWidget>().FakedObject);
// Getting the faked instance:
var faked = fake.FakedObject;
}
public void Calls_to_returns_fake_configuraion_for_the_faked_object_when_function_call_is_specified()
{
Expression<Func<IFoo, int>> callSpecification = x => x.Baz();
var callConfig = A.Fake<IReturnValueArgumentValidationConfiguration<int>>();
var config = A.Fake<IStartConfiguration<IFoo>>();
A.CallTo(() => config.CallsTo(callSpecification)).Returns(callConfig);
var fake = new Fake<IFoo>();
A.CallTo(() => this.startConfigurationFactory.CreateConfiguration<IFoo>(A<FakeManager>.That.Fakes(fake.FakedObject))).Returns(config);
var result = fake.CallsTo(callSpecification);
Assert.That(result, Is.SameAs(callConfig));
}
public void Calls_to_returns_fake_configuration_for_the_faked_object_when_void_call_is_specified()
{
Expression<Action<IFoo>> callSpecification = x => x.Bar();
var callConfig = A.Fake<IVoidArgumentValidationConfiguration>();
var config = A.Fake<IStartConfiguration<IFoo>>();
A.CallTo(() => config.CallsTo(callSpecification)).Returns(callConfig);
var fake = new Fake<IFoo>();
A.CallTo(() => this.startConfigurationFactory.CreateConfiguration<IFoo>(A<FakeManager>.That.Fakes(fake.FakedObject))).Returns(config);
var result = fake.CallsTo(callSpecification);
result.Should().BeSameAs(callConfig);
}
