public async Task AssignBatchActionResultsAsync(IODataClient client,
ODataResponse batchResponse, IList<Func<IODataClient, Task>> actions, IList<int> responseIndexes)
{
var exceptions = new List<Exception>();
for (var actionIndex = 0; actionIndex < actions.Count && !exceptions.Any(); actionIndex++)
{
var responseIndex = responseIndexes[actionIndex];
if (responseIndex >= 0 && responseIndex < batchResponse.Batch.Count)
{
var actionResponse = batchResponse.Batch[responseIndex];
if (actionResponse.Exception != null)
{
exceptions.Add(actionResponse.Exception);
}
else if (actionResponse.StatusCode >= (int)HttpStatusCode.BadRequest)
{
exceptions.Add(WebRequestException.CreateFromStatusCode((HttpStatusCode)actionResponse.StatusCode));
}
else
{
await actions[actionIndex](new ODataClient(client as ODataClient, actionResponse));
}
}
}
if (exceptions.Any())
{
throw exceptions.First();
}
}
public async Task<ODataRequest> CreateBatchRequestAsync(
IODataClient client, IList<Func<IODataClient, Task>> actions, IList<int> responseIndexes)
{
// Write batch operations into a batch content
var lastOperationId = 0;
foreach (var action in actions)
{
await action(client);
var responseIndex = -1;
if (this.LastOperationId > lastOperationId)
{
lastOperationId = LastOperationId;
responseIndex = lastOperationId - 1;
}
responseIndexes.Add(responseIndex);
}
if (this.HasOperations)
{
// Create batch request message
var requestMessage = await EndBatchAsync();
return new ODataRequest(RestVerbs.Post, _session, ODataLiteral.Batch, requestMessage);
}
else
{
return null;
}
}
public TestBase()
{
#if NETFX_CORE
_serviceUri = "http://NORTHWIND/Northwind.svc/";
#else
_service = new TestService(typeof(NorthwindService));
_serviceUri = _service.ServiceUri.AbsoluteUri;
#endif
_client = CreateClientWithDefaultSettings();
}
public virtual async Task CustomActionMethodWithSingleDtoReturnValueTest()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
await client.TestModels()
.CustomActionMethodWithSingleDtoReturnValueTest()
.ExecuteAsSingleAsync();
}
}
public override async Task <string> AddUserAsync(string username, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(username))
{
throw new ArgumentException("Username cannot be null or empty", nameof(username));
}
IODataClient client = GetODataClient();
string logon = IDIR.Logon(username);
Logger.Debug("Adding {Username} to project", username);
User user = await _userSearchService.SearchAsync(username);
SystemUser entry = await client
.For <SystemUser>()
.Filter(_ => _.DomainName == logon)
.Select(_ => _.SystemUserId)
.FindEntryAsync(cancellationToken);
if (entry == null)
{
Logger.Information("{Username} does not exist, creating a new record", username);
BusinessUnit rootBusinessUnit = await GetRootBusinessUnit(client, cancellationToken);
// populate the SystemUser with required attributes
entry = new SystemUser
{
Firstname = user.FirstName,
Lastname = user.LastName,
DomainName = IDIR.Logon(username),
InternalEMailAddress = user.Email,
BusinessUnit = rootBusinessUnit,
IsDisabled = false,
SharePointEmailAddress = user.UserPrincipalName
};
await client
.For <SystemUser>()
.Set(entry)
.InsertEntryAsync(cancellationToken);
}
else
{
Logger.Information("{@SystemUser} exists ensuring the user is enabled", entry);
await UpdateSystemUserDisableFlag(client, entry.SystemUserId, user, false, cancellationToken);
}
return(string.Empty);
}
public virtual async Task TestTimeZonesInCustomActionsWithoutClientsDemand()
{
IValueChecker valueChecker = A.Fake <IValueChecker>();
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(valueChecker);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
DateTimeOffset date = new DateTimeOffset(2016, 1, 1, 10, 30, 0, TimeSpan.Zero);
await client.TestModels()
.TimeZoneTests(simpleDate: date,
datesArray: new[] { date, date },
simpleDto: new TestModel {
StringProperty = " ", DateProperty = date, Id = 1, Version = 1
},
entitiesArray: new[]
{
new TestModel
{
StringProperty = " ", DateProperty = date, Id = 2, Version = 2
},
new TestModel
{
StringProperty = " ", DateProperty = date, Id = 3, Version = 3
}
}).ExecuteAsync();
A.CallTo(() => valueChecker.CheckValue(A <DateTimeOffset> .That.Matches(dt => dt.Year == 2016)))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue(A <List <DateTimeOffset> > .That.Matches(dates => dates.SequenceEqual(new List <DateTimeOffset> {
date, date
}))))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue(A <TestModel> .That.Matches(tm => tm.DateProperty == date)))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue(A <List <TestModel> > .That.Matches(tms => tms.First().DateProperty == date && tms.Last().DateProperty == date)))
.MustHaveHappenedOnceExactly();
}
}
public virtual async Task WebApiExceptionHandlerFilterAttributeMustReturnKnownErrorReasonPhraseAndNotFoundStatusCodeAndCorrelationIdInResponseWhenResourceNotFoundExceptionThrownsInWebApi()
{
IEmailService emailService = A.Fake <IEmailService>();
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Throws(new ResourceNotFoundException("Test"));
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(emailService);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token, afterResponse: message =>
{
if (message.StatusCode == HttpStatusCode.NotFound)
{
Assert.AreEqual(BitMetadataBuilder.KnownError, message.ReasonPhrase);
ILogger logger = TestDependencyManager.CurrentTestDependencyManager.Objects
.OfType <ILogger>().Last();
Guid correlationId = (Guid)logger.LogData.Single(logData => logData.Key == "X-CorrelationId").Value;
Assert.AreEqual(correlationId.ToString(), message.Headers.Single(h => h.Key == "X-CorrelationId").Value.Single());
}
});
try
{
await client.Controller <TestModelsController, TestModel>()
.Action(nameof(TestModelsController.SendEmail))
.Set(new TestModelsController.EmailParameters {
to = "Someone", title = "Email title", message = "Email message"
})
.ExecuteAsync();
Assert.Fail();
}
catch (WebRequestException ex)
{
Assert.IsTrue(ex.Response.Contains("Test"));
Assert.AreEqual(HttpStatusCode.NotFound, ex.Code);
}
}
}
public virtual async Task WebApiExceptionHandlerFilterAttributeMustReturnKnownErrorReasonPhraseAndNotFoundStatusCodeAndXCorrelationIdInResponseWhenResourceNotFoundExceptionThrownsInWebApi()
{
IEmailService emailService = A.Fake <IEmailService>();
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Throws(new ResourceNotFoundException("Test"));
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(emailService);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.BuildTestODataClient(token: token, odataClientSettings: new ODataClientSettings
{
AfterResponse = message =>
{
if (message.StatusCode == HttpStatusCode.NotFound)
{
Assert.AreEqual(BitMetadataBuilder.KnownError, message.ReasonPhrase);
Assert.IsTrue(message.Headers.Any(h => h.Key == "Reason-Phrase" && h.Value.Any(v => v == BitMetadataBuilder.KnownError)));
ILogger logger = testEnvironment.GetObjects <ILogger>().Last();
string xCorrelationId = (string)logger.LogData.Single(logData => logData.Key == "X-Correlation-ID").Value;
Assert.AreEqual(xCorrelationId, message.Headers.Single(h => h.Key == "X-Correlation-ID").Value.Single());
}
}
});
try
{
await client.TestModels()
.SendEmail(to: "Someone", title: "Email title", message: "Email message")
.ExecuteAsync();
Assert.Fail();
}
catch (WebRequestException ex)
{
Assert.IsTrue(ex.Response.Contains("Test"));
Assert.AreEqual(HttpStatusCode.NotFound, ex.Code);
}
}
}
/// <summary>
/// Registers new user. If userName gets provided, it uses that for registration. Otherwise, it creates random user name.
/// </summary>
/// <returns>UserName. Useful when you've not provided fixed user name, so you can retrive generated user name's value.</returns>
public static async Task <string> RegisterNewUser(this ToDoLineTestEnv testEnv, string userName = null, string password = "******")
{
userName = userName ?? Guid.NewGuid().ToString("N");
IODataClient client = testEnv.Server.BuildODataClient(odataRouteName: "ToDoLine");
await client.UserRegistration()
.Register(new UserRegistrationDto {
UserName = userName, Password = password
})
.ExecuteAsync();
return(userName);
}
protected TestBase(string serviceUri, ODataPayloadFormat payloadFormat)
{
//services.odata.org only works with Tls 1.2
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;
if (serviceUri.Contains("%28readwrite%29") || serviceUri == TripPinV4ReadWriteUri)
{
serviceUri = GetReadWriteUri(serviceUri).GetAwaiter().GetResult();
}
_serviceUri = new Uri(serviceUri);
_payloadFormat = payloadFormat;
_client = CreateClientWithDefaultSettings();
}
public virtual async Task EnumTest_CSClient()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs {
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
DtoWithEnum dtoWithEnum = await client.DtoWithEnum()
.GetDtoWithEnumsByGender(TestGender.Man)
.ExecuteAsSingleAsync();
Assert.AreEqual(TestGender.Man, dtoWithEnum.Gender);
Assert.AreEqual(true, await client.DtoWithEnum()
.PostDtoWithEnum(dtoWithEnum)
.ExecuteAsScalarAsync <bool>());
ODataBatch batchClient = testEnvironment.Server.BuildODataBatchClient(token: token);
batchClient += bc => bc.DtoWithEnum()
.GetDtoWithEnumsByGender2(TestGender2.Man)
.ExecuteAsEnumerableAsync();
batchClient += bc => bc.DtoWithEnum()
.GetDtoWithEnumsByGender(TestGender.Man)
.ExecuteAsEnumerableAsync();
await batchClient.ExecuteAsync();
/*Assert.AreEqual(true, await client.DtoWithEnum()
* .TestEnumsArray(new[] { TestGender2.Man, TestGender2.Woman })
* .ExecuteAsScalarAsync<bool>());*/
DtoWithEnumController firstCallController = TestDependencyManager.CurrentTestDependencyManager.Objects
.OfType <DtoWithEnumController>()
.First();
DtoWithEnumController secondCallController = TestDependencyManager.CurrentTestDependencyManager.Objects
.OfType <DtoWithEnumController>()
.ElementAt(2);
A.CallTo(() => firstCallController.GetDtoWithEnumsByGender(TestGender.Man))
.MustHaveHappenedOnceExactly();
A.CallTo(() => secondCallController.GetDtoWithEnumsByGender2(TestGender2.Man))
.MustHaveHappenedOnceExactly();
}
}
public async Task LoginAndSubmitNewEvlRequestAndFindExpertForItTest()
{
using (SanaapTestEnvironment testEnv = new SanaapTestEnvironment())
{
TokenResponse token = await testEnv.Server.Login("1270340050", "09033610498", "SanaapResOwner", "secret");
HttpClient httpClient = testEnv.Server.BuildHttpClient(token);
MultipartFormDataContent content = new MultipartFormDataContent
{
//new StringContent(JsonConvert.SerializeObject(new EvlRequestDto
//{
// AccidentDate = DateTimeOffset.UtcNow,
// CompanyId = 1,
// AccidentReason = "Test",
// InsuranceNumber = "123-456",
// InsuranceTypeEnum = InsuranceType.Sales,
// Latitude = 12,
// Longitude = 12,
// VehicleKindId = 1,
// VehicleNumber = "ایران - ب 44 678"
//}), Encoding.UTF8, "application/json"),
{ new StreamContent(File.OpenRead(@"C:\Users\SOFT\Desktop\Mohammad.png")), Guid.Parse("9bbd650e-3415-494d-b382-623a0840ab5a").ToString(), Guid.Parse("9bbd650e-3415-494d-b382-623a0840ab5a").ToString() }
};
HttpRequestMessage submitEvlRequest = new HttpRequestMessage(HttpMethod.Post, "api/evl-requests/submit-evl-request")
{
Content = content
};
HttpResponseMessage submitEvlRequestExpertResponse = await httpClient.SendAsync(submitEvlRequest);
submitEvlRequestExpertResponse.EnsureSuccessStatusCode();
EvlRequestDto evlRequest = JsonConvert.DeserializeObject <EvlRequestDto>(await submitEvlRequestExpertResponse.Content.ReadAsStringAsync());
IODataClient odataClient = testEnv.Server.BuildODataClient(odataRouteName: "Sanaap", token: token);
EvlRequestExpertDto evlRequestExpert = await odataClient.Controller <EvlRequestExpertsController, EvlRequestExpertDto>()
.Function(nameof(EvlRequestExpertsController.FindEvlRequestExpert))
.Set(new { evlRequestId = evlRequest.Id })
.FindEntryAsync();
evlRequestExpert = await odataClient.Controller <EvlRequestExpertsController, EvlRequestExpertDto>()
.Function(nameof(EvlRequestExpertsController.FindEvlRequestExpert))
.Set(new { evlRequestId = evlRequest.Id })
.FindEntryAsync();
}
}
public async Task LogExceptionWhenEmailSendFailedAndTryForTheSecondTime()
{
IEmailService emailService = A.Fake <IEmailService>();
TaskCompletionSource <bool> emailSent = new TaskCompletionSource <bool>();
int tryCount = 0;
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Invokes(() =>
{
tryCount++;
if (tryCount == 2)
{
emailSent.SetResult(true);
return;
}
throw new InvalidOperationException();
});
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(emailService);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
string jobId = (await client.TestModels()
.SendEmailUsingBackgroundJobService(to: "Someone", title: "Email title", message: "Email message")
.ExecuteAsScalarAsync <Guid>()).ToString();
Assert.AreEqual(true, await emailSent.Task);
ILogger logger = TestDependencyManager.CurrentTestDependencyManager
.Objects.OfType <ILogger>()
.Last();
A.CallTo(() => logger.LogException(A <Exception> .That.Matches(e => e is InvalidOperationException), A <string> .That.Matches(errMsg => errMsg.Contains(jobId))))
.MustHaveHappenedOnceExactly();
Assert.AreEqual(2, tryCount);
}
}
public virtual async Task ValidateODataSqlBuilderResults()
{
IValueChecker valueChecker = A.Fake <IValueChecker>();
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(valueChecker);
}
}))
{
Token token = await testEnvironment.Server.LoginWithCredentials("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.BuildTestODataClient(token: token);
await client.TestModels()
.TestSqlBuilder()
.Where(t => (t.Id == 1 && t.StringProperty.ToLower().Contains("Test")) || t.Id == 3)
.OrderBy(t => t.Id)
.ThenByDescending(t => t.StringProperty)
.Top(10)
.Skip(7)
.ExecuteAsEnumerableAsync();
A.CallTo(() => valueChecker.CheckValue((long?)10))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue((long?)7))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue("(([TestModel].[Id] = @Param1 AND [TestModel].[StringProperty] LIKE @Param2) OR [TestModel].[Id] = @Param3)"))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue("[TestModel].[Id],[TestModel].[StringProperty] DESC"))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue(A <object[]> .That.Matches(parameters => (long)parameters[0] == 1 && (string)parameters[1] == "%Test%" && (long)parameters[2] == 3)))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue("select * from Test.TestModels as [TestModel] where (([TestModel].[Id] = @Param1 AND [TestModel].[StringProperty] LIKE @Param2) OR [TestModel].[Id] = @Param3) order by [TestModel].[Id],[TestModel].[StringProperty] DESC offset 7 rows fetch next 10 rows only"))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue("select count_big(1) from Test.TestModels as [TestModel] where (([TestModel].[Id] = @Param1 AND [TestModel].[StringProperty] LIKE @Param2) OR [TestModel].[Id] = @Param3)"))
.MustHaveHappenedOnceExactly();
A.CallTo(() => valueChecker.CheckValue(false))
.MustHaveHappenedOnceExactly();
}
}
public virtual async Task TestTimeZonesInUrlWithoutClientDemand()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
IEnumerable <TestModel> testModels = await client.TestModels()
.Where(tm => tm.DateProperty == new DateTimeOffset(2016, 1, 1, 10, 30, 0, TimeSpan.Zero))
.FindEntriesAsync();
Assert.AreEqual(1, testModels.Count());
}
}
public override async Task <bool> UserHasAccessAsync(string username)
{
if (string.IsNullOrEmpty(username))
{
throw new ArgumentException("Username cannot be null or empty", nameof(username));
}
IODataClient client = GetODataClient();
string logon = IDIR.Logon(username);
var entry = await GetSystemUserByLogon(client, logon);
return(entry?.IsDisabled != null && !entry.IsDisabled.Value);
}
private Task <IDictionary <string, object> > UpdateSystemUserDisableFlag(IODataClient client, Guid systemUserId, bool isDisabled)
{
_logger.LogDebug("Updating SystemUser with {SystemUserId} with isDisabled flag set to {UsDisabled} in Dynamics", systemUserId, isDisabled);
// using the untyped version because the typed version was giving an error:
//
// Microsoft.OData.ODataException: The property 'isdisabled' does not exist on type 'Microsoft.Dynamics.CRM.systemuser'.
// Make sure to only use property names that are defined by the type or mark the type as open type.
//
return(client
.For("systemuser")
.Key(systemUserId)
.Set(new { isdisabled = isDisabled })
.UpdateEntryAsync());
}
public BreathingSpaceBrowseGateway(IODataClient client,
DynamicsGatewayOptions options)
{
_client = client;
_options = options;
_taskBrowseFunctions = new Dictionary <BreathingSpaceBrowseTask, Func <Guid, bool, Task <BreathingSpaceBrowseResponse> > >
{
{ BreathingSpaceBrowseTask.DebtsToBeReviewed, BrowseDebtsToBeReviewedAsync },
{ BreathingSpaceBrowseTask.ClientsToBeReviewed, BrowseClientsToBeReviewedAsync },
{ BreathingSpaceBrowseTask.NewDebtsProposed, BrowseNewDebtsProposedAsync },
{ BreathingSpaceBrowseTask.DebtsToBeTransferred, BrowseDebtsToBeTransferredAsync },
{ BreathingSpaceBrowseTask.ClientsToBeTransferred, BrowseClientsToBeTransferred },
{ BreathingSpaceBrowseTask.ClientsTransferredToMoneyAdviser, BrowseClientsTransferredToMoneyAdviser }
};
}
public CommonDynamicsGateway(
IODataClient client,
DynamicsGatewayOptions options,
ILogger <CommonDynamicsGateway> logger,
IMapperService mapperService,
AuditContext auditContext,
IAuditService auditService)
{
_logger = logger;
_client = client;
_options = options;
_mapperService = mapperService;
_auditContext = auditContext;
_auditService = auditService;
}
public async Task SendEmailUsingBackgroundJobWorkerAndWebApi()
{
IEmailService emailService = A.Fake <IEmailService>();
TaskCompletionSource <bool> emailSent = new TaskCompletionSource <bool>();
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Invokes(() =>
{
emailSent.SetResult(true);
});
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(emailService);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
string jobId = (await client.Controller <TestModelsController, TestModel>()
.Action(nameof(TestModelsController.SendEmailUsingBackgroundJobService))
.Set(new TestModelsController.EmailParameters {
to = "Someone", title = "Email title", message = "Email message"
})
.ExecuteAsScalarAsync <Guid>()).ToString();
IODataClient bitODataClient = testEnvironment.Server.BuildODataClient(token: token, odataRouteName: "Bit");
JobInfoDto jobInfo = await bitODataClient.Controller <JobsInfoController, JobInfoDto>()
.Key(jobId)
.FindEntryAsync();
Assert.AreEqual(true, await emailSent.Task);
await Task.Delay(TimeSpan.FromSeconds(1));
jobInfo = await bitODataClient.Controller <JobsInfoController, JobInfoDto>()
.Key(jobId)
.FindEntryAsync();
Assert.AreEqual("Succeeded", jobInfo.State);
}
}
public override async Task <string> AddUserAsync(string username)
{
if (string.IsNullOrEmpty(username))
{
throw new ArgumentException("Username cannot be null or empty", nameof(username));
}
IODataClient client = GetODataClient();
string logon = IDIR.Logon(username);
SystemUser entry = await GetSystemUserByLogon(client, logon);
if (entry == null)
{
_logger.LogInformation("{Username} does not exist, creating a new record", username);
User user = await _userSearchService.SearchAsync(username);
BusinessUnit rootBusinessUnit = await GetRootBusinessUnit(client);
// populate the SystemUser with required attributes
entry = new SystemUser
{
Firstname = user.FirstName,
Lastname = user.LastName,
DomainName = IDIR.Logon(username),
InternalEMailAddress = user.Email,
BusinessUnit = rootBusinessUnit,
IsDisabled = false
};
entry = await client
.For <SystemUser>()
.Set(entry)
.InsertEntryAsync();
}
else if (entry.IsDisabled != null && entry.IsDisabled.Value)
{
_logger.LogInformation("{@SystemUser} exists but is disabled, enabling user", entry);
await UpdateSystemUserDisableFlag(client, entry.SystemUserId, false);
}
else
{
_logger.LogInformation("{@SystemUser} exists and is already enabled user", entry);
}
return(string.Empty);
}
/// <summary>
/// Registers new user. If userName gets provided, it uses that for registration. Otherwise, it creates random user name.
/// </summary>
/// <returns>UserName. Useful when you've not provided fixed user name, so you can retrive generated user name's value.</returns>
public static async Task <string> RegisterNewUser(this ToDoLineTestEnv testEnv, string userName = null)
{
userName = userName ?? Guid.NewGuid().ToString("N");
IODataClient client = testEnv.Server.BuildODataClient(odataRouteName: "ToDoLine");
await client.Controller <UserRegistrationController, UserRegistrationDto>()
.Action(nameof(UserRegistrationController.Register))
.Set(new UserRegistrationController.RegisterArgs {
userRegistration = new UserRegistrationDto {
UserName = userName, Password = "******"
}
})
.ExecuteAsync();
return(userName);
}
public virtual async Task InsertAndUpdateTogether()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
ODataBatch batchClient = testEnvironment.Server.BuildODataBatchClient(token: token);
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
TestModel modelBeforeInsert = new TestModel
{
StringProperty = "Test",
Version = 1
};
batchClient += bc => bc.Controller <TestModelsController, TestModel>()
.Set(modelBeforeInsert)
.CreateEntryAsync();
long modelBeforeUpdateId = await client.Controller <TestModelsController, TestModel>()
.Top(1)
.Select(t => t.Id)
.FindScalarAsync <long>();
batchClient += bc => bc.Controller <TestModelsController, TestModel>()
.Key(modelBeforeUpdateId)
.Set(new { StringProperty = "Test2" })
.UpdateEntryAsync();
await batchClient.ExecuteAsync();
IRepository <TestModel> testModelsRepository =
TestDependencyManager.CurrentTestDependencyManager.Objects
.OfType <IRepository <TestModel> >()
.Last();
A.CallTo(() => testModelsRepository.UpdateAsync(
A <TestModel> .That.Matches(testModel => testModel.StringProperty == "Test2"),
A <CancellationToken> .Ignored))
.MustHaveHappenedOnceExactly();
A.CallTo(() => testModelsRepository.AddAsync(A <TestModel> .That.Matches(testModel => testModel.StringProperty == "Test"), A <CancellationToken> .Ignored))
.MustHaveHappenedOnceExactly();
}
}
public virtual async Task TestTimeZonesInUrlWithClientDemand()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token, beforeRequest: message =>
{
message.Headers.Add("Desired-Time-Zone", "Iran Standard Time");
message.Headers.Add("Current-Time-Zone", "Afghanistan Standard Time");
});
IEnumerable <TestModel> testModels = await client.Controller <TestModelsController, TestModel>()
.Where(tm => tm.DateProperty == new DateTimeOffset(2016, 1, 1, 9, 30, 0, TimeSpan.Zero))
.FindEntriesAsync();
Assert.AreEqual(1, testModels.Count());
}
}
public async Task TestPartialUpdate()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
long modelBeforeUpdateId = await client.Controller <TestModelsController, TestModel>()
.Top(1)
.Select(t => t.Id)
.FindScalarAsync <long>();
TestModel modelAfterUpdate = await client.Controller <TestModelsController, TestModel>()
.Key(modelBeforeUpdateId)
.Set(new { StringProperty = "Test2" })
.UpdateEntryAsync();
Assert.AreEqual("Test2", modelAfterUpdate.StringProperty);
TestModelsController testModelsController = TestDependencyManager.CurrentTestDependencyManager.Objects
.OfType <TestModelsController>()
.Last();
A.CallTo(() => testModelsController.PartialUpdate(modelBeforeUpdateId,
A <Delta <TestModel> > .That.Matches(
testModelDelta =>
testModelDelta.GetChangedPropertyNames().Single() == nameof(TestModel.StringProperty)),
A <CancellationToken> .Ignored))
.MustHaveHappenedOnceExactly();
IRepository <TestModel> testModelsRepository =
TestDependencyManager.CurrentTestDependencyManager.Objects
.OfType <IRepository <TestModel> >()
.Last();
A.CallTo(() => testModelsRepository.UpdateAsync(
A <TestModel> .That.Matches(testModel => testModel.StringProperty == "Test2"),
A <CancellationToken> .Ignored))
.MustHaveHappenedOnceExactly();
}
}
private async Task <SystemUser> GetSystemUserByLogon(IODataClient client, string logon)
{
_logger.LogDebug("Getting SystemUser with {DomainName} from Dynamics", logon);
var systemUser = await client
.For <SystemUser>()
.Filter(_ => _.DomainName == logon)
.FindEntryAsync();
if (systemUser != null)
{
_logger.LogDebug("Found SystemUser {@SystemUser}", new { systemUser.DomainName, systemUser.IsDisabled, systemUser.SystemUserId });
}
else
{
_logger.LogDebug("SystemUser with {DomainName} not found", logon);
}
return(systemUser);
}
public virtual async Task SimpleODataInCSharpClientTest()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
Token token = await testEnvironment.Server.LoginWithCredentials("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.BuildTestODataClient(token: token);
Assert.AreEqual(3, await client.Simple().Sum(1, 2).ExecuteAsScalarAsync <int>());
}
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
Token token = await testEnvironment.Server.LoginWithCredentials("ValidUserName", "ValidPassword", clientId : "TestResOwner");
HttpClient client = testEnvironment.Server.BuildHttpClient(token: token);
Assert.AreEqual(3, await client.Simple().Sum(1, 2));
}
}
/// <summary>
/// Login with provided user name. If registerNewUserByRandomUserName gets provided 'true' then it calls <see cref="RegisterNewUser(ToDoLineTestEnv, string)"/> first.
/// You've to either provide a valid userName or pass registerNewUserByRandomUserName 'true'. It generates a random userName and returns that to you in case no userName is provided for registration.
/// </summary>
public static async Task <(string userName, IODataClient loggedInClient)> LoginInToApp(this ToDoLineTestEnv testEnv, bool registerNewUserByRandomUserName, string userName = null)
{
if (registerNewUserByRandomUserName == true)
{
userName = await RegisterNewUser(testEnv, userName);
}
else
{
if (userName == null)
{
throw new ArgumentNullException(nameof(userName));
}
}
TokenResponse token = await testEnv.Server.Login(userName, password : "******", clientId : "ToDoLine", secret : "secret");
IODataClient loggedInClient = testEnv.Server.BuildODataClient(odataRouteName: "ToDoLine", token: token);
return(userName, loggedInClient);
}
public virtual async Task WebApiTraceWritterShouldLogCorrelationIdAndExceptionDetails()
{
IEmailService emailService = A.Fake <IEmailService>();
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Throws(new AppException("Test"));
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = manager =>
{
manager.RegisterInstance(emailService);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
try
{
await client.Controller <TestModelsController, TestModel>()
.Action(nameof(TestModelsController.SendEmail))
.Set(new TestModelsController.EmailParameters {
to = "Someone", title = "Email title", message = "Email message"
})
.ExecuteAsync();
Assert.Fail();
}
catch (WebRequestException)
{
ILogger logger = TestDependencyManager.CurrentTestDependencyManager.Objects
.OfType <ILogger>().Last();
Assert.IsTrue(logger.LogData.Single(ld => ld.Key == "X-CorrelationId").Value is Guid);
Assert.AreEqual(typeof(AppException).GetTypeInfo().FullName, logger.LogData.Single(ld => ld.Key == "WebExceptionType").Value);
Assert.IsTrue(((string)(logger.LogData.Single(ld => ld.Key == "WebException").Value)).Contains("Bit.Owin.Exceptions.AppException: Test"));
}
}
}
public virtual async Task CreateODataLinkAndCallItTest()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.BuildTestODataClient(token: token);
string newUrl = await client.TestModels()
.CreateODataLinkSample()
.ExecuteAsScalarAsync <string>();
int sumResult = (await(await testEnvironment.Server.BuildHttpClient(token)
.GetAsync(newUrl))
.EnsureSuccessStatusCode()
.Content
.ReadAsAsync <ODataResponse <int> >()).Value;
Assert.AreEqual(3, sumResult);
}
}
public override async Task <bool> UserHasAccessAsync(string username, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(username))
{
throw new ArgumentException("Username cannot be null or empty", nameof(username));
}
IODataClient client = GetODataClient();
string logon = IDIR.Logon(username);
Logger.Debug("Checking {Username} has access to project", username);
SystemUser entry = await client
.For <SystemUser>()
.Filter(_ => _.DomainName == logon && _.IsDisabled == false)
.Select(_ => _.SystemUserId)
.FindEntryAsync(cancellationToken);
return(entry != null);
}
public virtual async Task LogOperationArgsFilterAttributeShouldLogOperationArgs()
{
IEmailService emailService = A.Fake <IEmailService>();
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Throws <InvalidOperationException>();
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = manager =>
{
manager.RegisterInstance(emailService);
}
}))
{
TokenResponse token = await testEnvironment.Server.Login("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.Server.BuildODataClient(token: token);
try
{
await client.Controller <TestModelsController, TestModel>()
.Action(nameof(TestModelsController.SendEmail))
.Set(new TestModelsController.EmailParameters {
to = "Someone", title = "Email title", message = "Email message"
})
.ExecuteAsync();
Assert.Fail();
}
catch (WebRequestException)
{
ILogStore logStore = TestDependencyManager.CurrentTestDependencyManager.Objects
.OfType <ILogStore>().Last();
A.CallTo(() => logStore.SaveLogAsync(A <LogEntry> .That.Matches(log => ((TestModelsController.EmailParameters)((KeyValuePair <string, object>[])log.LogData.Single(ld => ld.Key == "OperationArgs").Value)[0].Value).to == "Someone")))
.MustHaveHappened(Repeated.Exactly.Once);
}
}
}
public virtual async Task LogOperationArgsFilterAttributeShouldLogOperationArgs()
{
IEmailService emailService = A.Fake <IEmailService>();
A.CallTo(() => emailService.SendEmail(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Throws <InvalidOperationException>();
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment(new TestEnvironmentArgs
{
AdditionalDependencies = (manager, services) =>
{
manager.RegisterInstance(emailService);
}
}))
{
Token token = await testEnvironment.Server.LoginWithCredentials("ValidUserName", "ValidPassword", clientId : "TestResOwner");
IODataClient client = testEnvironment.BuildTestODataClient(token: token);
try
{
await client.TestModels()
.SendEmail(to: "Someone", title: "Email title", message: "Email message")
.ExecuteAsync();
Assert.Fail();
}
catch (WebRequestException)
{
ILogStore logStore = testEnvironment.GetObjects <ILogStore>().Last();
A.CallTo(() => logStore.SaveLogAsync(A <LogEntry> .That.Matches(log => ((TestModelsController.EmailParameters)((KeyValuePair <string, object>[])log.LogData.Single(ld => ld.Key == "OperationArgs").Value)[0].Value).to == "Someone")))
.MustHaveHappenedOnceExactly();
A.CallTo(() => logStore.SaveLogAsync(A <LogEntry> .That.Matches(log => ((string)log.LogData.Single(ld => ld.Key == "OperationName").Value) == "SendEmail")))
.MustHaveHappenedOnceExactly();
A.CallTo(() => logStore.SaveLogAsync(A <LogEntry> .That.Matches(log => ((string)log.LogData.Single(ld => ld.Key == "ControllerName").Value) == "TestModels")))
.MustHaveHappenedOnceExactly();
}
}
}
public TestBase()
{
_client = CreateClientWithDefaultSettings();
}
public DataApiService(IODataClient client)
{
this.client = client;
}
protected WebApiTestsBase(ODataClientSettings settings)
{
_client = new ODataClient(settings);
}
private async Task RunClient(IODataClient client, int productID, ExecutionSummary result)
{
try
{
var product = await client.FindEntryAsync(string.Format("Products({0})", productID));
if (productID != Convert.ToInt32(product["ProductID"]))
{
lock (result)
{
result.NonEqualCount++;
}
}
}
catch (Exception)
{
lock (result)
{
result.ExceptionCount++;
}
}
finally
{
lock (result)
{
result.ExecutionCount++;
}
}
}
protected TestBase()
{
_client = CreateClient(this.MetadataFile);
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataBatch"/> class.
/// </summary>
/// <param name="client">The OData client which settings will be used to create a batch.</param>
public ODataBatch(IODataClient client)
{
_client = new ODataClient((client as ODataClient).Session.Settings, _entryMap);
}