public CanPayWithAccount()
{
var edoContextMock = MockEdoContextFactory.Create();
var bookingRecordsManager = new BookingRecordsManager(edoContextMock.Object, Mock.Of <IDateTimeProvider>(), Mock.Of <ITagProcessor>(),
Mock.Of <IAccommodationService>(), Mock.Of <IAccommodationBookingSettingsService>());
var dateTimeProvider = new DefaultDateTimeProvider();
_accountPaymentService = new AccountPaymentService(Mock.Of <IAccountPaymentProcessingService>(), edoContextMock.Object,
dateTimeProvider, Mock.Of <IAccountManagementService>(), Mock.Of <IEntityLocker>(), bookingRecordsManager);
edoContextMock
.Setup(c => c.AgencyAccounts)
.Returns(DbSetMockProvider.GetDbSetMock(new List <AgencyAccount>
{
new AgencyAccount
{
Id = 1,
Balance = 0,
Currency = Currencies.USD,
AgencyId = 1,
IsActive = true
},
new AgencyAccount
{
Id = 3,
Balance = 5,
Currency = Currencies.USD,
AgencyId = 3,
IsActive = true
}
}));
}
public CanPayWithAccount()
{
var edoContextMock = MockEdoContextFactory.Create();
var dateTimeProvider = new DefaultDateTimeProvider();
_accountPaymentService = new AccountPaymentService(Mock.Of <IAccountPaymentProcessingService>(), edoContextMock.Object,
dateTimeProvider, Mock.Of <IBalanceManagementNotificationsService>());
edoContextMock
.Setup(c => c.AgencyAccounts)
.Returns(DbSetMockProvider.GetDbSetMock(new List <AgencyAccount>
{
new AgencyAccount
{
Id = 1,
Balance = 0,
Currency = Currencies.USD,
AgencyId = 1,
IsActive = true
},
new AgencyAccount
{
Id = 3,
Balance = 5,
Currency = Currencies.USD,
AgencyId = 3,
IsActive = true
}
}));
}
private UserController GetUserController(UserDbContext userContext)
{
IUserRepository repository = new UserRepositoryInMemory(userContext);
IMediator mockedMediator = GetMockedMediator(repository);
IDateTimeProvider defaultDateTimeProvider = new DefaultDateTimeProvider();
var controller = new UserController(repository, mockedMediator, defaultDateTimeProvider);
return(controller);
}
public async Task Update_WithGetOptions_ShouldInsertAndUpdate()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var dateTimeProvider = new DefaultDateTimeProvider();
var mediatorMock = new Mock <IPublisher>();
var repository = new DbSettingsRepository(dbContextFactory, dateTimeProvider, mediatorMock.Object);
using (var _ = unitOfWorkFactory.Create())
{
// act (insert)
var options = repository.GetSettings <TestOptions>()
.Set(x => x.Number, 42)
.Set(x => x.Value, null)
.Set(x => x.State, AppState.Initialized);
var affected = await options.Update(cancellationToken);
// assert (insert)
Assert.AreEqual(3, affected);
var allSettings = await LoadSettings(dbContextFactory, cancellationToken);
var s1 = allSettings.SingleOrDefault(x => x.Id == "Montr.Core.Tests.Services.TestOptions:Number");
var s2 = allSettings.SingleOrDefault(x => x.Id == "Montr.Core.Tests.Services.TestOptions:Value");
var s3 = allSettings.SingleOrDefault(x => x.Id == "Montr.Core.Tests.Services.TestOptions:State");
Assert.IsNotNull(s1);
Assert.AreEqual("42", s1.Value);
Assert.IsNotNull(s2);
Assert.AreEqual(null, s2.Value);
Assert.IsNotNull(s3);
Assert.AreEqual("Initialized", s3.Value);
// act (update)
options = repository.GetSettings <TestOptions>()
.Set(x => x.State, AppState.None);
affected = await options.Update(cancellationToken);
// assert (update)
Assert.AreEqual(1, affected);
allSettings = await LoadSettings(dbContextFactory, cancellationToken);
s3 = allSettings.SingleOrDefault(x => x.Id == "Montr.Core.Tests.Services.TestOptions:State");
Assert.IsNotNull(s3);
Assert.AreEqual("None", s3.Value);
}
}
public void When_DefaultDateTimeProvider_Then_ReturnCurrentTime(int toleranceMs)
{
// Arrange
System.DateTime systemNow = System.DateTime.UtcNow;
IDateTimeProvider dtp = new DefaultDateTimeProvider();
// Act
System.DateTime dtpNow = dtp.UtcNow;
// Assert
dtpNow.Should().BeCloseTo(systemNow, toleranceMs);
}
public async Task GenerateNumber_IndependentNumerator_ShouldGenerate()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var dateTimeProvider = new DefaultDateTimeProvider();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var numeratorTagProvider = new TestNumberTagResolver {
EntityTypeCode = NumerableEntityTypeCode
};
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var service = new DbNumberGenerator(dbContextFactory, classifierRepositoryFactory, dateTimeProvider, new INumberTagResolver[] { numeratorTagProvider });
using (var _ = unitOfWorkFactory.Create())
{
var request = new GenerateNumberRequest
{
EntityTypeCode = NumerableEntityTypeCode,
EntityTypeUid = Guid.NewGuid()
};
await generator.InsertNumerator(new Numerator
{
Pattern = "{Company}-{Number}",
KeyTags = new[] { "Company" }
}, request, cancellationToken);
// act
numeratorTagProvider.Values = new Dictionary <string, string> {
{ "Company", "MT" }
};
var number1 = await service.GenerateNumber(request, cancellationToken);
var number2 = await service.GenerateNumber(request, cancellationToken);
numeratorTagProvider.Values = new Dictionary <string, string> {
{ "Company", "GT" }
};
var number3 = await service.GenerateNumber(request, cancellationToken);
var number4 = await service.GenerateNumber(request, cancellationToken);
// assert
Assert.AreEqual("MT-00001", number1);
Assert.AreEqual("MT-00002", number2);
Assert.AreEqual("GT-00001", number3);
Assert.AreEqual("GT-00002", number4);
}
}
public DataFixture()
{
IConfigurationRoot configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: false)
.Build();
String connectionString = configuration.GetConnectionString("DefaultConnection");
IDbConnection db = new SqlConnection(connectionString);
db.Open();
Transaction = db.BeginTransaction();
DateTimeProvider = new DefaultDateTimeProvider(new DateTime(2100, 1, 18));
Seed();
}
public async Task GenerateNumber_WithPeriodTags_ShouldGenerate()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var dateTimeProvider = new DefaultDateTimeProvider();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var numeratorTagProvider = new TestNumberTagResolver {
EntityTypeCode = NumerableEntityTypeCode
};
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var service = new DbNumberGenerator(dbContextFactory, classifierRepositoryFactory, dateTimeProvider, new INumberTagResolver[] { numeratorTagProvider });
using (var _ = unitOfWorkFactory.Create())
{
var request = new GenerateNumberRequest
{
EntityTypeCode = NumerableEntityTypeCode,
EntityTypeUid = Guid.NewGuid()
};
await generator.InsertNumerator(new Numerator
{
Periodicity = NumeratorPeriodicity.Year,
Pattern = "{Company}-{Number}-{Day}-{Month}-{Quarter}-{Year2}-{Year4}"
}, request, cancellationToken);
// act
numeratorTagProvider.Values = new Dictionary <string, string> {
{ "Company", "MT" }
};
numeratorTagProvider.Date = new DateTime(2003, 2, 5);
var number1 = await service.GenerateNumber(request, cancellationToken);
numeratorTagProvider.Date = new DateTime(1999, 10, 30);
var number2 = await service.GenerateNumber(request, cancellationToken);
// assert
Assert.AreEqual("MT-00001-05-02-1-03-2003", number1);
Assert.AreEqual("MT-00001-30-10-4-99-1999", number2);
}
}
public MasterDataDbGenerator(IUnitOfWorkFactory unitOfWorkFactory, IDbContextFactory dbContextFactory)
{
_dbContextFactory = dbContextFactory;
var dateTimeProvider = new DefaultDateTimeProvider();
var jsonSerializer = new NewtonsoftJsonSerializer();
var classifierTreeRepository = new DbClassifierTreeRepository(dbContextFactory);
var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
var fieldProviderRegistry = new DefaultFieldProviderRegistry();
fieldProviderRegistry.AddFieldType(typeof(TextField));
fieldProviderRegistry.AddFieldType(typeof(TextAreaField));
var dbFieldMetadataRepository = new DbFieldMetadataRepository(dbContextFactory, fieldProviderRegistry, jsonSerializer);
var dbFieldDataRepository = new DbFieldDataRepository(dbContextFactory, fieldProviderRegistry);
var dbFieldMetadataService = new DbFieldMetadataService(dbContextFactory, dateTimeProvider, jsonSerializer);
_classifierTypeService = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);
_getClassifierTreeListHandler = new GetClassifierTreeListHandler(classifierTreeRepository);
_insertClassifierTreeTypeHandler = new InsertClassifierTreeHandler(unitOfWorkFactory, dbContextFactory, _classifierTypeService);
_insertClassifierTypeHandler = new InsertClassifierTypeHandler(unitOfWorkFactory, _classifierTypeService, dbFieldMetadataService);
_insertClassifierGroupHandler = new InsertClassifierGroupHandler(unitOfWorkFactory, dbContextFactory, _classifierTypeService);
_classifierTypeRegistrator = new DefaultClassifierTypeRegistrator(new NullLogger <DefaultClassifierTypeRegistrator>(),
unitOfWorkFactory, _classifierTypeService, dbFieldMetadataService);
var classifierTypeMetadataService = new ClassifierTypeMetadataService(dbFieldMetadataRepository);
var classifierTreeService = new DefaultClassifierTreeService(classifierTreeRepository);
var dbNumberGenerator = new DbNumberGenerator(dbContextFactory, null, dateTimeProvider, null);
var classifierRepositoryFactory = new ClassifierRepositoryFactory(new DbClassifierRepository <Classifier>(
dbContextFactory, _classifierTypeService, classifierTreeService,
classifierTypeMetadataService, dbFieldDataRepository, dbNumberGenerator));
_insertClassifierHandler = new InsertClassifierHandler(unitOfWorkFactory, classifierRepositoryFactory);
_updateClassifierGroupHandler = new UpdateClassifierGroupHandler(unitOfWorkFactory, dbContextFactory, _classifierTypeService);
_deleteClassifierGroupHandler = new DeleteClassifierGroupHandler(unitOfWorkFactory, dbContextFactory, _classifierTypeService);
_insertClassifierLinkHandler = new InsertClassifierLinkHandler(unitOfWorkFactory, dbContextFactory, _classifierTypeService);
_getClassifierLinkListHandler = new GetClassifierLinkListHandler(dbContextFactory, _classifierTypeService);
}
/// <summary>
/// Initializes a new instance of the <see cref="CampaignApi"/> class.
/// </summary>
/// <returns></returns>
public CampaignApi(String authBasePath, string clientId, string clientSecret, string accountId)
{
this.Configuration = new Salesforce.MarketingCloud.Client.Configuration
{
AuthenticationInstanceUrl = authBasePath,
ClientId = clientId,
ClientSecret = clientSecret,
AccountId = accountId
};
var defaultDateTimeProvider = new DefaultDateTimeProvider();
var cacheService = new CacheService(defaultDateTimeProvider);
var apiClient = new ApiClient(authBasePath);
var authService = new AuthService(this.Configuration, apiClient, cacheService);
this.Configuration.ApiClient.RestClient.Authenticator =
new Salesforce.MarketingCloud.Authentication.OAuth2Authenticator(authService);
ExceptionFactory = Salesforce.MarketingCloud.Client.Configuration.DefaultExceptionFactory;
}
public GettingLinkData()
{
var edoContextMock = MockEdoContextFactory.Create();
edoContextMock.Setup(c => c.PaymentLinks)
.Returns(DbSetMockProvider.GetDbSetMock(Links));
var emptyOptions = Options.Create(new PaymentLinkOptions());
var companyServiceMock = new Mock <ICompanyService>();
companyServiceMock.Setup(c => c.Get())
.Returns(Task.FromResult(Result.Success(new CompanyInfo())));
var dateTimeProvider = new DefaultDateTimeProvider();
_linkStorage = new PaymentLinksStorage(edoContextMock.Object,
dateTimeProvider,
emptyOptions,
Mock.Of <ITagProcessor>());
}
/// <summary>
/// Initializes a new instance of the <see cref="AssetApi"/> class.
/// </summary>
/// <returns></returns>
internal BaseApi(string authBaseUrl, string clientId, string clientSecret, string accountId, string scope)
{
if (string.IsNullOrWhiteSpace(authBaseUrl))
{
throw new ArgumentException($"{nameof(authBaseUrl)} cannot not be null, empty or whitespace");
}
if (string.IsNullOrWhiteSpace(clientId))
{
throw new ArgumentException($"{nameof(clientId)} cannot not be null, empty or whitespace");
}
if (string.IsNullOrWhiteSpace(clientSecret))
{
throw new ArgumentException($"{nameof(clientSecret)} cannot not be null, empty or whitespace");
}
if (string.IsNullOrWhiteSpace(accountId))
{
throw new ArgumentException($"{nameof(accountId)} cannot not be null, empty or whitespace");
}
this.Configuration = new Salesforce.MarketingCloud.Client.Configuration
{
AuthenticationInstanceUrl = authBaseUrl,
ClientId = clientId,
ClientSecret = clientSecret,
AccountId = accountId,
Scope = scope
};
var defaultDateTimeProvider = new DefaultDateTimeProvider();
var cacheService = new CacheService(defaultDateTimeProvider);
var apiClient = new ApiClient(authBaseUrl);
var authService = new AuthService(this.Configuration, apiClient, cacheService);
this.Configuration.ApiClient.RestClient.Authenticator =
new Salesforce.MarketingCloud.Authentication.OAuth2Authenticator(authService);
ExceptionFactory = Salesforce.MarketingCloud.Client.Configuration.DefaultExceptionFactory;
}
public async Task CreateCompany_Should_CreateCompany()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var dateTimeProvider = new DefaultDateTimeProvider();
var mediatorMock = new Mock <IPublisher>();
var fieldProviderRegistry = new DefaultFieldProviderRegistry();
fieldProviderRegistry.AddFieldType(typeof(TextField));
// var dbFieldMetadataRepository = new DbFieldMetadataRepository(dbContextFactory, fieldProviderRegistry, new NewtonsoftJsonSerializer());
var dbFieldDataRepository = new DbFieldDataRepository(dbContextFactory, fieldProviderRegistry);
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var dbNumberGenerator = new DbNumberGenerator(dbContextFactory, classifierRepositoryFactory, dateTimeProvider, Array.Empty <INumberTagResolver>());
var dbDocumentService = new DbDocumentService(dbContextFactory, dbNumberGenerator, mediatorMock.Object);
var jsonSerializer = new DefaultJsonSerializer();
var auditLogService = new DbAuditLogService(dbContextFactory, jsonSerializer);
var classifierRegistrator = new DefaultClassifierRegistrator(NullLogger <DefaultClassifierRegistrator> .Instance, classifierRepositoryFactory);
var metadataRepositoryMock = new Mock <IRepository <FieldMetadata> >();
metadataRepositoryMock
.Setup(x => x.Search(It.IsAny <MetadataSearchRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => new SearchResult <FieldMetadata>
{
Rows = new FieldMetadata[]
{
new TextField {
Key = "test1", Active = true, System = false
},
new TextField {
Key = "test2", Active = true, System = false
},
new TextField {
Key = "test3", Active = true, System = false
}
}
});
var backgroundJobManagerMock = new Mock <IBackgroundJobManager>();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new CreateCompanyHandler(unitOfWorkFactory,
dbContextFactory, dateTimeProvider, metadataRepositoryMock.Object,
dbFieldDataRepository, classifierRepositoryFactory, dbDocumentService, auditLogService, backgroundJobManagerMock.Object);
using (var _ = unitOfWorkFactory.Create())
{
await generator.EnsureClassifierTypeRegistered(Numerator.GetDefaultMetadata(), cancellationToken);
await generator.EnsureClassifierTypeRegistered(DocumentType.GetDefaultMetadata(), cancellationToken);
foreach (var classifier in RegisterClassifiersStartupTask.GetClassifiers())
{
await classifierRegistrator.Register(classifier, cancellationToken);
}
// act
var company = new Company
{
ConfigCode = "company",
Name = "Montr Inc.",
Fields = new FieldData
{
{ "test1", "value1" },
{ "test2", "value2" },
{ "test3", "value3" }
}
};
var command = new CreateCompany
{
UserUid = Guid.NewGuid(),
Item = company
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.IsNotNull(result.Uid);
Assert.AreNotEqual(Guid.Empty, result.Uid);
// assert registration request inserted
DbDocument dbDocument;
using (var db = dbContextFactory.Create())
{
dbDocument = await db.GetTable <DbDocument>()
.Where(x => x.CompanyUid == result.Uid)
.SingleAsync(cancellationToken);
}
Assert.IsNotNull(dbDocument);
// assert registration request field data inserted
IList <DbFieldData> fieldData;
using (var db = dbContextFactory.Create())
{
fieldData = await db.GetTable <DbFieldData>()
.Where(x => x.EntityTypeCode == Document.TypeCode && x.EntityUid == dbDocument.Uid)
.ToListAsync(cancellationToken);
}
Assert.AreEqual(company.Fields.Count, fieldData.Count);
Assert.AreEqual(company.Fields["test1"], fieldData.Single(x => x.Key == "test1").Value);
Assert.AreEqual(company.Fields["test2"], fieldData.Single(x => x.Key == "test2").Value);
Assert.AreEqual(company.Fields["test3"], fieldData.Single(x => x.Key == "test3").Value);
}
}
public async Task GenerateNumber_QuarterPeriodicity_ShouldGenerate()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var dateTimeProvider = new DefaultDateTimeProvider();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var numeratorTagProvider = new TestNumberTagResolver
{
EntityTypeCode = NumerableEntityTypeCode,
Values = new Dictionary <string, string>()
};
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var service = new DbNumberGenerator(dbContextFactory, classifierRepositoryFactory, dateTimeProvider, new INumberTagResolver[] { numeratorTagProvider });
using (var _ = unitOfWorkFactory.Create())
{
var request = new GenerateNumberRequest
{
EntityTypeCode = NumerableEntityTypeCode,
EntityTypeUid = Guid.NewGuid()
};
await generator.InsertNumerator(new Numerator
{
Periodicity = NumeratorPeriodicity.Quarter,
Pattern = "{Company}-{Number}/{Year4}"
}, request, cancellationToken);
numeratorTagProvider.Values = new Dictionary <string, string> {
{ "Company", "MT" }
};
// act - Q1.2020 - first time
numeratorTagProvider.Date = new DateTime(2020, 01, 31);
var number1OfQ1 = await service.GenerateNumber(request, cancellationToken);
var number2OfQ1 = await service.GenerateNumber(request, cancellationToken);
// assert - Q1.2020 - first time
Assert.AreEqual("MT-00001/2020", number1OfQ1);
Assert.AreEqual("MT-00002/2020", number2OfQ1);
// act - Q3.2020
numeratorTagProvider.Date = new DateTime(2020, 07, 30);
var number1OfQ3 = await service.GenerateNumber(request, cancellationToken);
var number2OfQ3 = await service.GenerateNumber(request, cancellationToken);
// assert - Q3.2020
Assert.AreEqual("MT-00001/2020", number1OfQ3);
Assert.AreEqual("MT-00002/2020", number2OfQ3);
// act - Q1.2020 - second time
numeratorTagProvider.Date = new DateTime(2020, 02, 29);
var number3OfQ1 = await service.GenerateNumber(request, cancellationToken);
var number4OfQ1 = await service.GenerateNumber(request, cancellationToken);
// assert - Q1.2020 - second time
Assert.AreEqual("MT-00003/2020", number3OfQ1);
Assert.AreEqual("MT-00004/2020", number4OfQ1);
}
}
