public MarkupsApplyingOrder()
{
var allPolicies = _agentPolicies
.Union(_counterpartyPolicies)
.Union(_globalPolicies)
.Union(_agencyPolicies);
var edoContextMock = MockEdoContextFactory.Create();
edoContextMock.Setup(c => c.MarkupPolicies)
.Returns(DbSetMockProvider.GetDbSetMock(allPolicies));
var currencyRateServiceMock = new Mock <ICurrencyRateService>();
currencyRateServiceMock
.Setup(c => c.Get(It.IsAny <Currencies>(), It.IsAny <Currencies>()))
.Returns(new ValueTask <Result <decimal> >(Result.Success((decimal)1)));
var agentSettingsMock = new Mock <IAgentSettingsManager>();
agentSettingsMock
.Setup(s => s.GetUserSettings(It.IsAny <AgentContext>()))
.Returns(Task.FromResult(new AgentUserSettings(true, It.IsAny <Currencies>(), It.IsAny <Currencies>(), It.IsAny <int>())));
var accommodationBookingSettingsServiceMock = new Mock <IAccommodationBookingSettingsService>();
accommodationBookingSettingsServiceMock
.Setup(s => s.Get(It.IsAny <AgentContext>()))
.ReturnsAsync(new AccommodationBookingSettings(default, default, default, false, default));
public MarkupsApplyingOrder()
{
var allPolicies = _agentPolicies
.Union(_globalPolicies)
.Union(_agencyPolicies)
.ToList();
var edoContextMock = MockEdoContextFactory.Create();
edoContextMock.Setup(c => c.Agencies)
.Returns(DbSetMockProvider.GetDbSetMock(_agencies));
var currencyRateServiceMock = new Mock <ICurrencyRateService>();
currencyRateServiceMock
.Setup(c => c.Get(It.IsAny <Currencies>(), It.IsAny <Currencies>()))
.Returns(new ValueTask <Result <decimal> >(Result.Success((decimal)1)));
var markupPolicyStorage = new MarkupPolicyStorage(Mock.Of <IOptionsMonitor <MarkupPolicyStorageOptions> >(_ => _.CurrentValue ==
new MarkupPolicyStorageOptions {
Timeout = TimeSpan.FromMilliseconds(1)
}));
markupPolicyStorage.Set(allPolicies);
_markupPolicyService = new MarkupPolicyService(markupPolicyStorage);
var discountServiceMock = new Mock <IDiscountFunctionService>();
discountServiceMock.Setup(service => service.Get(It.IsAny <MarkupPolicy>(), It.IsAny <MarkupSubjectInfo>()))
.ReturnsAsync((price => new ValueTask <MoneyAmount>(price)));
_markupService = new MarkupService(_markupPolicyService, discountServiceMock.Object, new MarkupPolicyTemplateService(), currencyRateServiceMock.Object, new FakeMemoryFlow());
}
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 (AgentStatusManagementService, EdoContext) SetupData()
{
var relations = new[]
{
new AgentAgencyRelation
{
AgencyId = 1,
AgentId = 1,
IsActive = true
},
new AgentAgencyRelation
{
AgencyId = 1,
AgentId = 2,
IsActive = false
},
new AgentAgencyRelation
{
AgencyId = 1,
AgentId = 3,
IsActive = true
}
};
var edoContextMock = MockEdoContextFactory.Create();
var service = new AgentStatusManagementService(edoContextMock.Object);
edoContextMock.Setup(x => x.AgentAgencyRelations).Returns(DbSetMockProvider.GetDbSetMock(relations));
return(service, edoContextMock.Object);
}
private BookingRecordsUpdater CreateBookingRecordsUpdaterService()
{
var context = MockEdoContextFactory.Create();
context
.Setup(x => x.Bookings)
.Returns(DbSetMockProvider.GetDbSetMock(Bookings));
context
.Setup(x => x.Agents)
.Returns(DbSetMockProvider.GetDbSetMock(Agents));
context
.Setup(x => x.Agencies)
.Returns(DbSetMockProvider.GetDbSetMock(Agencies));
return(new BookingRecordsUpdater(
Mock.Of <IDateTimeProvider>(),
Mock.Of <IBookingInfoService>(),
_notificationServiceMock.Object,
_bookingMoneyReturnServiceMock.Object,
_documentsMailingServiceMock.Object,
_supplierOrderServiceMock.Object,
Mock.Of <INotificationService>(),
Mock.Of <IBookingChangeLogService>(),
Mock.Of <IBookingAnalyticsService>(),
context.Object,
Mock.Of <ILogger <BookingRecordsUpdater> >()));
}
public InvitationCreationWays()
{
_userInvitationService = new FakeUserInvitationService();
var counterpartyServiceMock = new Mock <ICounterpartyService>();
counterpartyServiceMock
.Setup(c => c.Get(It.IsAny <int>(), default))
.ReturnsAsync(Result.Success(FakeCounterpartyInfo));
counterpartyServiceMock
.Setup(c => c.GetAgency(It.IsAny <int>(), Agent))
.ReturnsAsync(Result.Success(FakeAgencyInfo));
var optionsMock = new Mock <IOptions <AgentInvitationOptions> >();
optionsMock.Setup(o => o.Value).Returns(new AgentInvitationOptions
{
EdoPublicUrl = It.IsAny <string>(),
MailTemplateId = It.IsAny <string>()
});
_invitationService = new AgentInvitationService(optionsMock.Object,
_userInvitationService,
counterpartyServiceMock.Object,
MockEdoContextFactory.Create().Object);
}
private static BookingDocumentsService CreateBookingDocumentsService(Booking booking)
{
// If property is not initialized thrown NullReferenceException
booking.Rooms = new List <BookedRoom>();
var edoContext = MockEdoContextFactory.Create();
edoContext.Setup(c => c.Bookings)
.Returns(DbSetMockProvider.GetDbSetMock(new List <Booking> {
booking
}));
var bookingRecordManager = new BookingRecordsManager(
edoContext.Object,
Mock.Of <IDateTimeProvider>(),
Mock.Of <ITagProcessor>(),
Mock.Of <IAccommodationService>(),
Mock.Of <IAccommodationBookingSettingsService>());
return(new BookingDocumentsService(
edoContext.Object,
Mock.Of <IOptions <BankDetails> >(),
bookingRecordManager,
Mock.Of <IAccommodationService>(),
Mock.Of <ICounterpartyService>(),
Mock.Of <IInvoiceService>(),
Mock.Of <IReceiptService>(),
Mock.Of <IImageFileService>()));
}
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 async Task Generated_itn_numbers_should_be_unique()
{
var dbContext = CreateDbContextWithDuplicateItnValidation();
var tagProcessor = new TagProcessor(dbContext, Options.Create(new TagProcessingOptions()));
while (_currentItn < MaxItnNumbersCount)
{
await tagProcessor.GenerateItn();
}
EdoContext CreateDbContextWithDuplicateItnValidation()
{
var context = MockEdoContextFactory.Create();
context.Setup(e => e.GetNextItineraryNumber())
.Returns(() => Task.FromResult(++_currentItn));
context.Setup(e => e.RegisterItn(It.IsAny <string>()))
.Returns <string>(itn =>
{
if (_registeredItnNumbers.Contains(itn))
{
throw new AssertionFailedException($"ITN '{itn}' is duplicated after {_registeredItnNumbers.Count} generations");
}
_registeredItnNumbers.Add(itn);
return(Task.CompletedTask);
});
return(context.Object);
}
}
public AgentPermissionManagementServiceTests()
{
var edoContextMock = MockEdoContextFactory.Create();
edoContextMock.Setup(x => x.AgentAgencyRelations).Returns(DbSetMockProvider.GetDbSetMock(_relations));
_agentPermissionManagementService = new AgentPermissionManagementService(edoContextMock.Object);
}
private static EdoContext CreateContext()
{
var context = MockEdoContextFactory.Create();
context
.Setup(x => x.Bookings)
.Returns(DbSetMockProvider.GetDbSetMock(Bookings));
return(context.Object);
}
public GetBalanceTests()
{
var entityLockerMock = new Mock <IEntityLocker>();
entityLockerMock.Setup(l => l.Acquire <It.IsAnyType>(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(Result.Success()));
var edoContextMock = MockEdoContextFactory.Create();
var mockedEdoContext = edoContextMock.Object;
_agencyAccountService = new AgencyAccountService(mockedEdoContext, entityLockerMock.Object,
Mock.Of <IManagementAuditService>(), Mock.Of <IAccountBalanceAuditService>());
var strategy = new ExecutionStrategyMock();
var dbFacade = new Mock <DatabaseFacade>(mockedEdoContext);
dbFacade.Setup(d => d.CreateExecutionStrategy()).Returns(strategy);
edoContextMock.Setup(c => c.Database).Returns(dbFacade.Object);
edoContextMock
.Setup(c => c.Agencies)
.Returns(DbSetMockProvider.GetDbSetMock(new List <Agency>
{
new Agency
{
Id = 1
},
// Having more than one element for predicates to be tested too
new Agency
{
Id = 2
},
}));
edoContextMock
.Setup(c => c.AgencyAccounts)
.Returns(DbSetMockProvider.GetDbSetMock(new List <AgencyAccount>
{
new AgencyAccount
{
Id = 1,
Balance = 1000,
Currency = Currencies.USD,
AgencyId = 1,
IsActive = true
},
new AgencyAccount
{
Id = 1,
Balance = 0,
Currency = Currencies.USD,
AgencyId = 1,
IsActive = true
}
}));
}
public LinkCreation()
{
var edoContextMock = MockEdoContextFactory.Create();
_edoContextMock = edoContextMock;
_edoContextMock
.Setup(e => e.PaymentLinks.Add(It.IsAny <PaymentLink>()))
.Callback <PaymentLink>(link => LastCreatedLink = link);
}
private static BookingDocumentsService CreateBookingDocumentsService()
{
var edoContext = MockEdoContextFactory.Create();
edoContext.Setup(c => c.Agents)
.Returns(DbSetMockProvider.GetDbSetMock(new[]
{
new Agent
{
FirstName = "Test",
LastName = "Test",
Id = 1
}
}));
var accommodation = new Accommodation(htId: string.Empty,
name: string.Empty,
accommodationAmenities: new List <string>(0),
additionalInfo: new Dictionary <string, string>(),
category: string.Empty,
contacts: new ContactInfo(),
location: new LocationInfo(countryCode: string.Empty,
countryHtId: string.Empty,
country: string.Empty,
localityHtId: string.Empty,
locality: string.Empty,
localityZoneHtId: string.Empty,
localityZone: string.Empty,
coordinates: new GeoPoint(0d, 0d),
address: string.Empty,
locationDescriptionCode: new LocationDescriptionCodes(),
new List <PoiInfo>(0)),
photos: new List <ImageInfo>(),
AccommodationRatings.NotRated,
schedule: new ScheduleInfo(checkInTime: string.Empty,
checkOutTime: string.Empty),
textualDescriptions: new List <TextualDescription>(0),
type: PropertyTypes.Hotels,
suppliers: new List <SupplierInfo>(0),
modified: DateTime.UtcNow);
var accommodationMapperClient = new Mock <IAccommodationMapperClient>();
accommodationMapperClient.Setup(c => c.GetAccommodation(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(accommodation);
return(new BookingDocumentsService(
edoContext.Object,
Mock.Of <IOptions <BankDetails> >(),
accommodationMapperClient.Object,
Mock.Of <IInvoiceService>(),
Mock.Of <IReceiptService>(),
Mock.Of <IImageFileService>(),
Mock.Of <IAdminAgencyManagementService>()));
}
public RefundMoneyTests()
{
var entityLockerMock = new Mock <IEntityLocker>();
entityLockerMock.Setup(l => l.Acquire <It.IsAnyType>(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(Result.Success()));
var edoContextMock = MockEdoContextFactory.Create();
var edoContextMock1 = edoContextMock;
var mockedEdoContext = edoContextMock.Object;
var accountPaymentProcessingService = new AccountPaymentProcessingService(
mockedEdoContext, entityLockerMock.Object, Mock.Of <IAccountBalanceAuditService>());
var dateTimeProviderMock = new Mock <IDateTimeProvider>();
dateTimeProviderMock.Setup(d => d.UtcNow()).Returns(CancellationDate);
_accountPaymentService = new AccountPaymentService(accountPaymentProcessingService, mockedEdoContext,
dateTimeProviderMock.Object, Mock.Of <IBalanceManagementNotificationsService>());
var strategy = new ExecutionStrategyMock();
var dbFacade = new Mock <DatabaseFacade>(mockedEdoContext);
dbFacade.Setup(d => d.CreateExecutionStrategy()).Returns(strategy);
edoContextMock.Setup(c => c.Database).Returns(dbFacade.Object);
edoContextMock1
.Setup(c => c.Agencies)
.Returns(DbSetMockProvider.GetDbSetMock(new List <Agency>
{
new Agency
{
Id = 1,
Name = "Agency",
ParentId = null,
},
}));
edoContextMock1
.Setup(c => c.AgencyAccounts)
.Returns(DbSetMockProvider.GetDbSetMock(new List <AgencyAccount>
{
_account,
}));
edoContextMock1
.Setup(c => c.Payments)
.Returns(DbSetMockProvider.GetDbSetMock(new List <Payment>
{
_payment,
}));
}
private static BookingDocumentsService CreateBookingDocumentsService(Booking booking, bool hasInvoices)
{
// If property is not initialized thrown NullReferenceException
booking.Rooms = new List <BookedRoom>();
var edoContext = MockEdoContextFactory.Create();
edoContext.Setup(c => c.Bookings)
.Returns(DbSetMockProvider.GetDbSetMock(new List <Booking> {
booking
}));
var bookingRecordManager = new BookingRecordsManager(
edoContext.Object,
Mock.Of <IDateTimeProvider>(),
Mock.Of <ITagProcessor>(),
Mock.Of <IAccommodationService>(),
Mock.Of <IAccommodationBookingSettingsService>());
var invoices = hasInvoices
? new List <(DocumentRegistrationInfo Metadata, BookingInvoiceData Data)>
{
(
new DocumentRegistrationInfo(It.IsAny <string>(), It.IsAny <DateTime>()),
new BookingInvoiceData(
new BookingInvoiceData.BuyerInfo(),
new BookingInvoiceData.SellerInfo(),
It.IsAny <string>(),
new List <BookingInvoiceData.InvoiceItemInfo>(),
new MoneyAmount(),
It.IsAny <DateTime>(),
It.IsAny <DateTime>(),
It.IsAny <DateTime>(),
It.IsAny <BookingPaymentStatuses>(),
It.IsAny <DateTime?>())
)
}
: new List <(DocumentRegistrationInfo Metadata, BookingInvoiceData Data)>();
var invoiceServiceMock = new Mock <IInvoiceService>();
invoiceServiceMock.Setup(i => i.Get <BookingInvoiceData>(It.IsAny <ServiceTypes>(), It.IsAny <ServiceSource>(), It.IsAny <string>()))
.ReturnsAsync(invoices);
return(new BookingDocumentsService(
edoContext.Object,
Mock.Of <IOptions <BankDetails> >(),
bookingRecordManager,
Mock.Of <IAccommodationService>(),
Mock.Of <ICounterpartyService>(),
invoiceServiceMock.Object,
Mock.Of <IReceiptService>(),
Mock.Of <IImageFileService>()));
}
public PermissionCheckerTests()
{
var edoContextMock = MockEdoContextFactory.Create();
edoContextMock.Setup(x => x.AgentRoles)
.Returns(DbSetMockProvider.GetDbSetMock(_roles));
edoContextMock.Setup(x => x.AgentAgencyRelations)
.Returns(DbSetMockProvider.GetDbSetMock(_relations));
_permissionChecker = new PermissionChecker(edoContextMock.Object, new FakeDoubleFlow());
}
public AgentServiceTests()
{
var edoContextMock = MockEdoContextFactory.Create();
edoContextMock.Setup(x => x.Counterparties).Returns(DbSetMockProvider.GetDbSetMock(_counterparties));
edoContextMock.Setup(x => x.Agencies).Returns(DbSetMockProvider.GetDbSetMock(_agencies));
edoContextMock.Setup(x => x.Agents).Returns(DbSetMockProvider.GetDbSetMock(_agents));
edoContextMock.Setup(x => x.AgentAgencyRelations).Returns(DbSetMockProvider.GetDbSetMock(_relations));
edoContextMock.Setup(x => x.MarkupPolicies).Returns(DbSetMockProvider.GetDbSetMock(new List <MarkupPolicy>()));
_agentService = new AgentService(edoContextMock.Object, new DefaultDateTimeProvider(), new MarkupPolicyTemplateService());
}
private static BookingsProcessingService CreateProcessingService()
{
var context = MockEdoContextFactory.Create();
context
.Setup(c => c.Bookings)
.Returns(DbSetMockProvider.GetDbSetMock(Bookings));
return(new BookingsProcessingService(Mock.Of <IBookingPaymentService>(),
Mock.Of <IBookingManagementService>(),
Mock.Of <IBookingMailingService>(),
context.Object));
}
public AgentServiceTests()
{
var edoContextMock = MockEdoContextFactory.Create();
edoContextMock.Setup(x => x.Agencies).Returns(DbSetMockProvider.GetDbSetMock(_agencies));
edoContextMock.Setup(x => x.Agents).Returns(DbSetMockProvider.GetDbSetMock(_agents));
edoContextMock.Setup(x => x.AgentAgencyRelations).Returns(DbSetMockProvider.GetDbSetMock(_relations));
edoContextMock.Setup(x => x.MarkupPolicies).Returns(DbSetMockProvider.GetDbSetMock(new List <MarkupPolicy>()));
edoContextMock.Setup(x => x.DisplayMarkupFormulas).Returns(DbSetMockProvider.GetDbSetMock(new List <DisplayMarkupFormula>()));
edoContextMock.Setup(x => x.AgentRoles).Returns(DbSetMockProvider.GetDbSetMock(_agentRoles));
_agentService = new AgentService(edoContextMock.Object, new DefaultDateTimeProvider());
}
public Task <TResult> ExecuteAsync <TState, TResult>(
TState state,
Func <DbContext, TState, CancellationToken, Task <TResult> > operation,
Func <DbContext, TState, CancellationToken, Task <ExecutionResult <TResult> > > verifySucceeded,
CancellationToken cancellationToken = new CancellationToken())
{
var edoContextMock = MockEdoContextFactory.Create();
var dbFacade = new Mock <DatabaseFacade>(edoContextMock.Object);
dbFacade.Setup(d => d.CurrentTransaction).Returns((IDbContextTransaction)null);
edoContextMock.Setup(c => c.Database).Returns(dbFacade.Object);
return(operation(edoContextMock.Object, default, CancellationToken.None));
private static TagProcessor MockTagProcessor(string prefix)
{
var context = MockEdoContextFactory.Create();
context.Setup(e => e.GenerateNextItnMember(It.IsAny <string>()))
.Returns(() => Task.FromResult(It.IsAny <int>()));
context.Setup(e => e.RegisterItn(It.IsAny <string>()))
.Returns(() => Task.CompletedTask);
return(new TagProcessor(context.Object, Options.Create(new TagProcessingOptions
{
ReferenceCodePrefix = prefix
})));
}
private BookingsProcessingService CreateProcessingService(IEnumerable <Booking> bookings)
{
var context = MockEdoContextFactory.Create();
context.Setup(c => c.Bookings)
.Returns(DbSetMockProvider.GetDbSetMock(bookings));
var service = new BookingsProcessingService(Mock.Of <IBookingPaymentService>(),
Mock.Of <IBookingManagementService>(),
Mock.Of <IBookingMailingService>(),
context.Object);
return(service);
}
public UserSettings()
{
var edoContextMock = MockEdoContextFactory.Create();
_settingsManager = new AgentSettingsManager(edoContextMock.Object, new NewtonsoftJsonSerializer());
edoContextMock
.Setup(c => c.Agents)
.Returns(DbSetMockProvider.GetDbSetMock(new List <Agent>
{
new Agent
{
Id = 1,
}
}));
}
public HasPermissionTests()
{
var edoContextMock = MockEdoContextFactory.Create();
edoContextMock.Setup(x => x.Administrators)
.Returns(DbSetMockProvider.GetDbSetMock(_administrators));
edoContextMock.Setup(x => x.AdministratorRoles)
.Returns(DbSetMockProvider.GetDbSetMock(_administratorRoles));
var tokenInfoAccessorMock = new Mock <ITokenInfoAccessor>();
tokenInfoAccessorMock.Setup(x => x.GetIdentity())
.Returns("hash");
_administratorContext = new HttpBasedAdministratorContext(edoContextMock.Object, tokenInfoAccessorMock.Object);
}
private BookingsProcessingService CreateProcessingService(IBookingMailingService mailingService)
{
var context = MockEdoContextFactory.Create();
context.Setup(c => c.Bookings)
.Returns(DbSetMockProvider.GetDbSetMock(Bookings));
context.Setup(c => c.Agents)
.Returns(DbSetMockProvider.GetDbSetMock(new[] { Agent }));
var service = new BookingsProcessingService(Mock.Of <IBookingPaymentService>(),
Mock.Of <IBookingManagementService>(),
mailingService,
context.Object);
return(service);
}
private static BookingsProcessingService CreateProcessingService()
{
var context = MockEdoContextFactory.Create();
context
.Setup(c => c.Bookings)
.Returns(DbSetMockProvider.GetDbSetMock(Bookings));
return(new BookingsProcessingService(Mock.Of <IBookingAccountPaymentService>(),
Mock.Of <IBookingCreditCardPaymentService>(),
Mock.Of <ISupplierBookingManagementService>(),
Mock.Of <IBookingNotificationService>(),
Mock.Of <IBookingReportsService>(),
context.Object,
Mock.Of <IBookingRecordsUpdater>(),
Mock.Of <IDateTimeProvider>()));
}
private BookingsProcessingService CreateProcessingService(IBookingPaymentService bookingPaymentService = null,
IBookingManagementService bookingManagementService = null)
{
bookingPaymentService ??= Mock.Of <IBookingPaymentService>();
bookingManagementService ??= Mock.Of <IBookingManagementService>();
var context = MockEdoContextFactory.Create();
context.Setup(c => c.Bookings)
.Returns(DbSetMockProvider.GetDbSetMock(Bookings));
var service = new BookingsProcessingService(bookingPaymentService,
bookingManagementService,
Mock.Of <IBookingMailingService>(),
context.Object);
return(service);
}
public AddMoneyTests()
{
var entityLockerMock = new Mock <IEntityLocker>();
entityLockerMock.Setup(l => l.Acquire <It.IsAnyType>(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(Result.Success()));
_edoContextMock = MockEdoContextFactory.Create();
_mockedEdoContext = _edoContextMock.Object;
_counterpartyAccountService = new CounterpartyAccountService(_mockedEdoContext, entityLockerMock.Object, Mock.Of <IAccountBalanceAuditService>());
var strategy = new ExecutionStrategyMock();
var dbFacade = new Mock <DatabaseFacade>(_mockedEdoContext);
dbFacade.Setup(d => d.CreateExecutionStrategy()).Returns(strategy);
_edoContextMock.Setup(c => c.Database).Returns(dbFacade.Object);
}
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>());
}
