public NumberOfMovementsTests()
{
shipmentRepository = A.Fake <IShipmentInfoRepository>();
movementRepository = A.Fake <IMovementRepository>();
numberOfMovements = new NumberOfMovements(movementRepository, shipmentRepository);
}
public MovementViewModel(
INavigationService navigationService,
IMovementRepository repositoryService
)
{
_navigationService = navigationService;
_repositoryService = repositoryService;
IsPositive = false;
if (_navigationService.NavigationData != null)
{
if (_navigationService.NavigationData is int)
{
GetMovement((int)_navigationService.NavigationData);
}
else if (_navigationService.NavigationData is Tuple <int, int> )
{
Date = new DateTime(
((Tuple <int, int>)_navigationService.NavigationData).Item2,
((Tuple <int, int>)_navigationService.NavigationData).Item1,
1);
}
else if (_navigationService.NavigationData is Tuple <int, int, int> )
{
Date = new DateTime(
((Tuple <int, int, int>)_navigationService.NavigationData).Item3,
((Tuple <int, int, int>)_navigationService.NavigationData).Item2,
((Tuple <int, int, int>)_navigationService.NavigationData).Item1);
}
}
}
public MovementSender(
IMessageService messageService,
IMovementRepository movementRepository)
{
_messageService = messageService;
_movementRepository = movementRepository;
}
public NextAvailableMovementNumberGeneratorTests()
{
movementRepository = A.Fake<IMovementRepository>();
movements = new List<Movement>();
A.CallTo(() => movementRepository.GetAllMovements(NotificationId)).Returns(movements);
nextAvailableMovementNumberGenerator = new NextAvailableMovementNumberGenerator(movementRepository);
}
public OutcomingServices(string dbString) : base(dbString)
{
UniqRep = new UniqueItemRepository(this.Context);
PoRep = new PositionRepository(this.Context);
SaRep = new StorageRepository(this.Context);
MoRep = new MovementRepository(this.Context);
}
public SetMultipleMovementFileIdHandlerTests()
{
var context = new TestIwsContext();
context.Users.Add(UserFactory.Create(TestIwsContext.UserId, AnyString, AnyString, AnyString, AnyString));
notificationId = Guid.NewGuid();
fileId = Guid.NewGuid();
var userId = TestIwsContext.UserId;
movementRepository = A.Fake <IMovementRepository>();
notificationRepository = A.Fake <INotificationApplicationRepository>();
fileRepository = A.Fake <IFileRepository>();
movementAuditRepository = A.Fake <IMovementAuditRepository>();
var userContext = A.Fake <IUserContext>();
A.CallTo(() => notificationRepository.GetById(notificationId))
.Returns(new TestableNotificationApplication()
{
NotificationNumber = NotificatioNumber
});
A.CallTo(() => fileRepository.Store(A <File> .Ignored)).Returns(fileId);
A.CallTo(() => userContext.UserId).Returns(userId);
handler = new SetMultipleMovementFileIdHandler(context, movementRepository, notificationRepository,
fileRepository, movementAuditRepository, userContext);
}
public NotificationMovementsQuantity(IMovementRepository movementRepository, IShipmentInfoRepository shipmentRepository,
IMovementPartialRejectionRepository movementPartialRejectionRepository)
{
this.movementRepository = movementRepository;
this.shipmentRepository = shipmentRepository;
this.movementPartialRejectionRepository = movementPartialRejectionRepository;
}
public GetReceiptRecoveryMovementsByNotificationIdHandler(
IMovementRepository movementRepository,
IMapper mapper)
{
this.movementRepository = movementRepository;
this.mapper = mapper;
}
public MovementQuantityTests()
{
movement = new TestableMovement
{
Status = MovementStatus.Received,
Receipt = new TestableMovementReceipt
{
Date = new DateTime(2015, 9, 1),
Decision = Core.MovementReceipt.Decision.Accepted,
QuantityReceived = new ShipmentQuantity(5, ShipmentQuantityUnits.Kilograms)
}
};
shipmentInfo = new TestableShipmentInfo
{
Quantity = 20,
Units = ShipmentQuantityUnits.Kilograms
};
movementRepository = A.Fake <IMovementRepository>();
shipmentRepository = A.Fake <IShipmentInfoRepository>();
movementPartialRejectionRepository = A.Fake <IMovementPartialRejectionRepository>();
movementQuantity = new NotificationMovementsQuantity(movementRepository, shipmentRepository, movementPartialRejectionRepository);
}
public MovementFactoryTests()
{
SystemTime.Freeze(Today);
shipmentRepository = A.Fake <IShipmentInfoRepository>();
movementRepository = A.Fake <IMovementRepository>();
assessmentRepository = A.Fake <INotificationAssessmentRepository>();
financialGuaranteeRepository = A.Fake <IFinancialGuaranteeRepository>();
consentRepository = A.Fake <INotificationConsentRepository>();
workingDayCalculator = A.Fake <IWorkingDayCalculator>();
notificationApplicationRepository = A.Fake <INotificationApplicationRepository>();
financialGuaranteeRepository = A.Fake <IFinancialGuaranteeRepository>();
movementPartialRejectionRepository = A.Fake <IMovementPartialRejectionRepository>();
dateValidator = A.Fake <IMovementDateValidator>();
var movementNumberGenerator = new MovementNumberGenerator(new NextAvailableMovementNumberGenerator(movementRepository),
movementRepository,
shipmentRepository);
var numberOfMovements = new NumberOfMovements(movementRepository, shipmentRepository);
var movementsQuatity = new NotificationMovementsQuantity(movementRepository, shipmentRepository, movementPartialRejectionRepository);
var numberOfActiveLoads = new NumberOfActiveLoads(movementRepository, financialGuaranteeRepository);
var consentPeriod = new ConsentPeriod(consentRepository, workingDayCalculator, notificationApplicationRepository);
factory = new MovementFactory(numberOfMovements,
movementsQuatity,
assessmentRepository,
movementNumberGenerator,
numberOfActiveLoads,
consentPeriod,
dateValidator,
financialGuaranteeRepository,
A.Fake <IUserContext>());
}
public SetMovementPartialRejectedHandlerTests()
{
var context = new TestIwsContext();
context.Users.Add(UserFactory.Create(TestIwsContext.UserId, AnyString, AnyString, AnyString, AnyString));
notificationId = Guid.NewGuid();
movementId = Guid.NewGuid();
rejectDate = SystemTime.UtcNow;
wasteDate = SystemTime.UtcNow;
partialRejectionMovement = A.Fake <IPartialRejectionMovement>();
movementRepository = A.Fake <IMovementRepository>();
var notificationRepository = A.Fake <INotificationApplicationRepository>();
var userContext = A.Fake <IUserContext>();
A.CallTo(() => notificationRepository.GetById(notificationId))
.Returns(new TestableNotificationApplication()
{
NotificationNumber = NotificatioNumber
});
A.CallTo(() => userContext.UserId).Returns(TestIwsContext.UserId);
handler = new RecordPartialRejectionInternalHandler(partialRejectionMovement, context);
}
public SaveMovementCompletedReceiptHandlerTests()
{
var context = new TestIwsContext();
context.Users.Add(UserFactory.Create(TestIwsContext.UserId, AnyString, AnyString, AnyString, AnyString));
notificationId = Guid.NewGuid();
movementId = Guid.NewGuid();
fileId = Guid.NewGuid();
var userContext = A.Fake <IUserContext>();
movementRepository = A.Fake <IMovementRepository>();
fileRepository = A.Fake <IFileRepository>();
notificationRepository = A.Fake <INotificationApplicationRepository>();
movementAuditRepository = A.Fake <IMovementAuditRepository>();
A.CallTo(() => notificationRepository.GetById(notificationId))
.Returns(new TestableNotificationApplication()
{
NotificationNumber = NotificationNumber
});
A.CallTo(() => fileRepository.Store(A <File> .Ignored)).Returns(fileId);
var nameGenerator = new CertificateOfRecoveryNameGenerator(notificationRepository);
var certificateFactory = new CertificateFactory();
handler = new SaveMovementCompletedReceiptHandler(context, fileRepository, movementRepository,
certificateFactory, nameGenerator, userContext, notificationRepository, movementAuditRepository);
}
public MonthViewModel(
INavigationService navigationService,
IMovementRepository repositoryService,
IDeviceService deviceService
)
{
_navigationService = navigationService;
_repositoryService = repositoryService;
_deviceService = deviceService;
SetCalendar();
ShowDayLetters();
ShowMonthMovements(GetMonth(_selectedMonth), _selectedYear);
GetBalance();
MessagingCenter.Subscribe <ViewModelBase, string>(this, "currency", (sender, arg) =>
{
CurrentCurrency = arg;
});
MessagingCenter.Subscribe <Movement>(this, "movement", (sender) =>
{
ShowMonthMovements(GetMonth(_selectedMonth), _selectedYear);
GetBalance();
});
}
public NextAvailableMovementNumberGeneratorTests()
{
movementRepository = A.Fake <IMovementRepository>();
movements = new List <Movement>();
A.CallTo(() => movementRepository.GetAllMovements(NotificationId)).Returns(movements);
nextAvailableMovementNumberGenerator = new NextAvailableMovementNumberGenerator(movementRepository);
}
public ReceiptRecoveryAlreadyRecievedRuleTests()
{
this.movementRepo = A.Fake <IMovementRepository>();
rule = new ReceiptRecoveryAlreadyReceivedRule(this.movementRepo);
notificationId = Guid.NewGuid();
}
public GetSubmittedMovementsByNotificationIdHandler(
IMovementRepository movementRepository,
IMapper mapper)
{
this.movementRepository = movementRepository;
this.mapper = mapper;
}
public SetMovementRejectedHandlerTests()
{
var context = new TestIwsContext();
context.Users.Add(UserFactory.Create(TestIwsContext.UserId, AnyString, AnyString, AnyString, AnyString));
notificationId = Guid.NewGuid();
movementId = Guid.NewGuid();
rejectDate = SystemTime.UtcNow;
rejectMovement = A.Fake <IRejectMovement>();
movementRepository = A.Fake <IMovementRepository>();
fileRepository = A.Fake <IFileRepository>();
movementAuditRepository = A.Fake <IMovementAuditRepository>();
var notificationRepository = A.Fake <INotificationApplicationRepository>();
var nameGenerator = new MovementFileNameGenerator(notificationRepository);
var certificateFactory = new CertificateFactory();
var userContext = A.Fake <IUserContext>();
A.CallTo(() => notificationRepository.GetById(notificationId))
.Returns(new TestableNotificationApplication()
{
NotificationNumber = NotificatioNumber
});
A.CallTo(() => fileRepository.Store(A <File> .Ignored)).Returns(Guid.NewGuid());
A.CallTo(() => userContext.UserId).Returns(TestIwsContext.UserId);
handler = new SetMovementRejectedHandler(rejectMovement, movementRepository, context, nameGenerator,
certificateFactory, fileRepository, movementAuditRepository, userContext);
}
public MovementFactoryTests()
{
SystemTime.Freeze(Today);
shipmentRepository = A.Fake<IShipmentInfoRepository>();
movementRepository = A.Fake<IMovementRepository>();
assessmentRepository = A.Fake<INotificationAssessmentRepository>();
financialGuaranteeRepository = A.Fake<IFinancialGuaranteeRepository>();
consentRepository = A.Fake<INotificationConsentRepository>();
workingDayCalculator = A.Fake<IWorkingDayCalculator>();
notificationApplicationRepository = A.Fake<INotificationApplicationRepository>();
financialGuaranteeRepository = A.Fake<IFinancialGuaranteeRepository>();
dateValidator = A.Fake<IMovementDateValidator>();
var movementNumberGenerator = new MovementNumberGenerator(new NextAvailableMovementNumberGenerator(movementRepository),
movementRepository,
shipmentRepository);
var numberOfMovements = new NumberOfMovements(movementRepository, shipmentRepository);
var movementsQuatity = new NotificationMovementsQuantity(movementRepository, shipmentRepository);
var numberOfActiveLoads = new NumberOfActiveLoads(movementRepository, financialGuaranteeRepository);
var consentPeriod = new ConsentPeriod(consentRepository, workingDayCalculator, notificationApplicationRepository);
factory = new MovementFactory(numberOfMovements,
movementsQuatity,
assessmentRepository,
movementNumberGenerator,
numberOfActiveLoads,
consentPeriod,
dateValidator,
financialGuaranteeRepository,
A.Fake<IUserContext>());
}
public GetRemainingShipmentsHandler(IMovementRepository movementRepository,
IShipmentInfoRepository shipmentRepository,
IFinancialGuaranteeRepository financialGuaranteeRepository)
{
this.movementRepository = movementRepository;
this.shipmentRepository = shipmentRepository;
this.financialGuaranteeRepository = financialGuaranteeRepository;
}
public CreateMovementInternalHandlerTests()
{
context = new TestIwsContext();
factory = A.Fake<ICapturedMovementFactory>();
movementRepository = A.Fake<IMovementRepository>();
handler = new CreateMovementInternalHandler(factory, movementRepository, context);
}
public PartialRejectMovementTests()
{
SystemTime.Freeze(Today);
movementRepository = A.Fake <IMovementRepository>();
movementPartialRejectionRepository = A.Fake <IMovementPartialRejectionRepository>();
partialRejectionFactory = new PartialRejectionMovement(movementRepository, movementPartialRejectionRepository);
}
public MovementService(
IMovementRepository movementRepository,
IResourceRepository resourceRepository
)
{
_movementRepository = movementRepository;
_resourceRepository = resourceRepository;
}
public RejectMovementTests()
{
SystemTime.Freeze(Today);
movementRepository = A.Fake <IMovementRepository>();
movementRejectionRepository = A.Fake <IMovementRejectionRepository>();
rejectFactory = new RejectMovement(movementRepository, movementRejectionRepository);
}
public RecordParialOperationCompleteInternalHandler(IMovementPartialRejectionRepository movementPartialRepository, IwsContext context, IUserContext userContext,
IMovementRepository movementRepository)
{
this.movementPartialRepository = movementPartialRepository;
this.context = context;
this.userContext = userContext;
this.movementRepository = movementRepository;
}
public MovementNumberGeneratorTests()
{
SystemTime.Freeze(new DateTime(2015, 1, 1));
movementRepository = A.Fake <IMovementRepository>();
shipmentRepository = A.Fake <IShipmentInfoRepository>();
generator = new MovementNumberGenerator(new NextAvailableMovementNumberGenerator(movementRepository), movementRepository, shipmentRepository);
}
public GetMovementSummaryHandler(IMapper mapper,
IMovementRepository movementRepository,
INotificationMovementsSummaryRepository summaryRepository)
{
this.movementRepository = movementRepository;
this.summaryRepository = summaryRepository;
this.mapper = mapper;
}
public CreateMovementInternalHandler(ICapturedMovementFactory factory,
IMovementRepository movementRepository,
IwsContext context)
{
this.factory = factory;
this.movementRepository = movementRepository;
this.context = context;
}
public GetMovementDateHistoryHandler(IMovementDateHistoryRepository historyRepository,
IMovementRepository movementRepository,
IMapper mapper)
{
this.historyRepository = historyRepository;
this.mapper = mapper;
this.movementRepository = movementRepository;
}
public MovementNumberGenerator(INextAvailableMovementNumberGenerator nextAvailableMovementNumberGenerator,
IMovementRepository movementRepository,
IShipmentInfoRepository shipmentRepository)
{
this.nextAvailableMovementNumberGenerator = nextAvailableMovementNumberGenerator;
this.movementRepository = movementRepository;
this.shipmentRepository = shipmentRepository;
}
public MovementNumberGeneratorTests()
{
SystemTime.Freeze(new DateTime(2015, 1, 1));
movementRepository = A.Fake<IMovementRepository>();
shipmentRepository = A.Fake<IShipmentInfoRepository>();
generator = new MovementNumberGenerator(new NextAvailableMovementNumberGenerator(movementRepository), movementRepository, shipmentRepository);
}
public SetMovementAcceptedHandler(IMovementRepository movementRepository, IwsContext context,
IUserContext userContext, IMovementAuditRepository movementAuditRepository)
{
this.movementRepository = movementRepository;
this.context = context;
this.userContext = userContext;
this.movementAuditRepository = movementAuditRepository;
}
public GetReceivedMovementsHandler(IMovementRepository movementRepository,
INotificationApplicationRepository notificationRepository,
IMapper mapper)
{
this.movementRepository = movementRepository;
this.notificationRepository = notificationRepository;
this.mapper = mapper;
}
public MovementNumberGenerator(INextAvailableMovementNumberGenerator nextAvailableMovementNumberGenerator,
IMovementRepository movementRepository,
IShipmentInfoRepository shipmentRepository)
{
this.nextAvailableMovementNumberGenerator = nextAvailableMovementNumberGenerator;
this.movementRepository = movementRepository;
this.shipmentRepository = shipmentRepository;
}
public QQuery(IUserRepository userRepository, IMovementRepository movementRepository)
{
Description = "Query raiz da interface BackEndTest para Audaces";
Field <ListGraphType <UserType> >(
"users",
description: "Busca todos os usuários",
resolve: context => userRepository.GetAll());
Field <UserType>(
"userById",
description: "Busca um usuário pelo seu Id",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IntGraphType> > {
Name = "id", Description = "Id do usuário"
}),
resolve: context => userRepository.GetById(context.GetArgument <int>("id")));
// ------------------------------------- movements -----------------------------------
Field <ListGraphType <MovementType> >(
"movements",
description: "Busca todas as movimentações",
resolve: context => movementRepository.GetAll());
Field <ListGraphType <MovementType> >(
"movementByUserId",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IntGraphType> > {
Name = "user", Description = "Id do usuário"
}),
description: "Busca todas as movimentações de um determinado usuário, dado seu Id",
resolve: context => movementRepository.GetAllMovementForUserId(context.GetArgument <int>("user")));
Field <IntGraphType>(
"balanceBetweenDates",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "start", Description = "Data de inicio"
},
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "end", Description = "Data do fim"
}),
description: "Busca o saldo global, entre duas datas",
resolve: context => movementRepository.balanceBetweenDates(context.GetArgument <string>("start"), context.GetArgument <string>("end")));
Field <IntGraphType>(
"balanceBetweenDatesByUser",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "start", Description = "Data de inicio"
},
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "end", Description = "Data do fim"
},
new QueryArgument <NonNullGraphType <IntGraphType> > {
Name = "userId", Description = "Id do usuário"
}),
description: "Busca o saldo do usuário, entre duas datas",
resolve: context => movementRepository.balanceBetweenDatesByUser(context.GetArgument <string>("start"), context.GetArgument <string>("end"),
context.GetArgument <int>("userId")));
}
public ReceiptRecoveryShipmentMustBePrenotifiedRuleTests()
{
movementRepo = A.Fake <IMovementRepository>();
notificationRepo = A.Fake <INotificationApplicationRepository>();
rule = new ReceiptRecoveryShipmentMustBePrenotifiedRule(movementRepo, notificationRepo);
notificationId = Guid.NewGuid();
A.CallTo(() => notificationRepo.GetById(notificationId)).Returns(A.Fake <NotificationApplication>());
}
public MovementBlockFactory(IMovementRepository movementRepository,
IMovementDetailsRepository movementDetailsRepository,
INotificationApplicationRepository notificationApplicationRepository,
IShipmentInfoRepository shipmentInfoRepository)
{
this.movementRepository = movementRepository;
this.notificationApplicationRepository = notificationApplicationRepository;
this.shipmentInfoRepository = shipmentInfoRepository;
this.movementDetailsRepository = movementDetailsRepository;
}
public GetMovementDateByMovementIdHandlerTests()
{
movement = new TestableMovement
{
Id = MovementId,
Date = MovementDate
};
repository = A.Fake<IMovementRepository>();
A.CallTo(() => repository.GetById(MovementId)).Returns(movement);
handler = new GetMovementDateByMovementIdHandler(repository);
request = new GetMovementDateByMovementId(MovementId);
}
public MovementQuantityTests()
{
movement = new TestableMovement
{
Status = MovementStatus.Received,
Receipt = new TestableMovementReceipt
{
Date = new DateTime(2015, 9, 1),
Decision = Core.MovementReceipt.Decision.Accepted,
QuantityReceived = new ShipmentQuantity(5, ShipmentQuantityUnits.Kilograms)
}
};
shipmentInfo = new TestableShipmentInfo
{
Quantity = 20,
Units = ShipmentQuantityUnits.Kilograms
};
movementRepository = A.Fake<IMovementRepository>();
shipmentRepository = A.Fake<IShipmentInfoRepository>();
movementQuantity = new NotificationMovementsQuantity(movementRepository, shipmentRepository);
}
public NumberOfActiveLoads(IMovementRepository movementRepository, IFinancialGuaranteeRepository financialGuaranteeRepository)
{
this.movementRepository = movementRepository;
this.financialGuaranteeRepository = financialGuaranteeRepository;
}
public NotificationMovementsQuantity(IMovementRepository movementRepository, IShipmentInfoRepository shipmentRepository)
{
this.movementRepository = movementRepository;
this.shipmentRepository = shipmentRepository;
}
public EnsureMovementNumberAvailableHandlerTests()
{
movementRepository = A.Fake<IMovementRepository>();
handler = new GetMovementIdIfExistsHandler(movementRepository);
}
public MovementAuthorization(INotificationApplicationAuthorization notificationAuthorization,
IMovementRepository repository)
{
this.notificationAuthorization = notificationAuthorization;
this.repository = repository;
}
public MovementNumberValidator(IMovementRepository repository)
{
this.repository = repository;
}
public RejectMovement(IMovementRepository movementRepository,
IMovementRejectionRepository movementRejectionRepository)
{
this.movementRepository = movementRepository;
this.movementRejectionRepository = movementRejectionRepository;
}
public NumberOfMovements(IMovementRepository movementRepository, IShipmentInfoRepository shipmentRepository)
{
this.movementRepository = movementRepository;
this.shipmentRepository = shipmentRepository;
}
public NextAvailableMovementNumberGenerator(IMovementRepository movementRepository)
{
this.movementRepository = movementRepository;
}
public MovementNumberValidatorTests()
{
repository = A.Fake<IMovementRepository>();
validator = new MovementNumberValidator(repository);
}
