@Test
public void testIsUserAssignedPrincipalFail() {
// given
final WorkflowActionModel mockAction = mock(WorkflowActionModel.class);
final UserModel mockUser = mock(UserModel.class);
when(userService.getCurrentUser()).thenReturn(mockUser);
// when
final boolean isAssigned = workflowActionService.isUserAssignedPrincipal(mockAction);
// then
assertThat(isAssigned).isFalse();
}
@Before
public void setUp() throws Exception {
createCoreData();
createDefaultCatalog();
productModel01 = productService.getProduct("testProduct1");
userModel01 = userService.getUser("anonymous");
userModel02 = userService.getCurrentUser();
oldMinimalRating = Config.getParameter(CustomerReviewConstants.KEYS.MINIMAL_RATING);
oldMaximalRating = Config.getParameter(CustomerReviewConstants.KEYS.MAXIMAL_RATING);
// Set some configuration values to be used generally in the tests
Config.setParameter(CustomerReviewConstants.KEYS.MINIMAL_RATING, String.valueOf(0));
Config.setParameter(CustomerReviewConstants.KEYS.MAXIMAL_RATING, String.valueOf(4));
}
@Test
public void testIsUserAssignedPrincipalForSameGroup() {
// given
final WorkflowActionModel mockAction = mock(WorkflowActionModel.class);
final UserModel mockUser = mock(UserModel.class);
final UserGroupModel mockGroup = mock(UserGroupModel.class);
when(mockAction.getPrincipalAssigned()).thenReturn(mockGroup);
when(userService.getCurrentUser()).thenReturn(mockUser);
when(mockUser.getAllGroups()).thenReturn((Set) Collections.singleton(mockGroup));
// when
final boolean isAssigned = workflowActionService.isUserAssignedPrincipal(mockAction);
// then
assertThat(isAssigned).isTrue();
}
private OrderModel createNewOrder() {
final OrderModel order = modelService.create(OrderModel.class);
final UserModel user = userService.getCurrentUser();
order.setUser(user);
order.setCurrency(commonI18NService.getBaseCurrency());
order.setDate(new java.util.Date());
order.setNet(Boolean.FALSE);
final OrderEntryModel entry1 = modelService.create(OrderEntryModel.class);
entry1.setOrder(order);
entry1.setQuantity(Long.valueOf(1));
entry1.setUnit(productService.getOrderableUnit(product1));
entry1.setProduct(product1);
entry1.setEntryNumber(Integer.valueOf(0));
final OrderEntryModel entry2 = modelService.create(OrderEntryModel.class);
entry2.setOrder(order);
entry2.setQuantity(Long.valueOf(1));
entry2.setUnit(productService.getOrderableUnit(product2));
entry2.setProduct(product2);
entry2.setEntryNumber(Integer.valueOf(1));
final OrderEntryModel entry3 = modelService.create(OrderEntryModel.class);
entry3.setOrder(order);
entry3.setQuantity(Long.valueOf(1));
entry3.setUnit(productService.getOrderableUnit(product3));
entry3.setProduct(product3);
entry3.setEntryNumber(Integer.valueOf(2));
final OrderEntryModel entry4 = modelService.create(OrderEntryModel.class);
entry4.setOrder(order);
entry4.setQuantity(Long.valueOf(1));
entry4.setUnit(productService.getOrderableUnit(product4));
entry4.setProduct(product4);
entry4.setEntryNumber(Integer.valueOf(3));
order.setEntries((List) Arrays.asList(entry1, entry2, entry3, entry4));
return order;
}
@Before
public void beforeTest() throws Exception {
MockitoAnnotations.initMocks(this);
// inject a mock payment provider
cardPaymentService.setCommandFactoryRegistry(mockupCommandFactoryRegistry);
paymentService.setCardPaymentService(cardPaymentService);
commerceCheckoutService.setPaymentService(paymentService);
createCoreData();
createDefaultCatalog();
importCsv("/energizercore/test/testOrganizations.csv", "utf-8");
importCsv("/energizercore/test/testB2BCommerceCart.csv", "utf-8");
final CartModel modelByExample = new CartModel();
modelByExample.setCode("dc_shhCart_b2bas");
final CartModel cart = flexibleSearchService.getModelByExample(modelByExample);
Assert.assertNotNull(cart);
cartService.setSessionCart(cart);
userService.setCurrentUser(cart.getUser());
if (flexibleSearchService
.search(
"SELECT {"
+ ServicelayerJobModel.PK
+ "} FROM {"
+ ServicelayerJobModel._TYPECODE
+ "} WHERE "
+ "{"
+ ServicelayerJobModel.SPRINGID
+ "}=?springid",
Collections.singletonMap("springid", "b2bAcceleratorCartToOrderJob"))
.getResult()
.isEmpty()) {
final ServicelayerJobModel servicelayerJobModel =
modelService.create(ServicelayerJobModel.class);
servicelayerJobModel.setCode("b2bAcceleratorCartToOrderJob");
servicelayerJobModel.setSpringId("b2bAcceleratorCartToOrderJob");
modelService.save(servicelayerJobModel);
}
final Date startDate = new Date();
final Integer day = Integer.valueOf(5);
final Integer week = Integer.valueOf(2);
final List<DayOfWeek> days = new ArrayList<DayOfWeek>();
days.add(DayOfWeek.TUESDAY);
days.add(DayOfWeek.FRIDAY);
triggerModel = modelService.create(TriggerModel.class);
triggerModel.setRelative(Boolean.TRUE);
triggerModel.setActivationTime(startDate);
triggerModel.setDay(day);
triggerModel.setWeekInterval(week);
triggerModel.setDaysOfWeek(days);
cartToOrderCronJob = modelService.create(CartToOrderCronJobModel.class);
cartToOrderCronJob.setCart(cartService.getSessionCart());
cartToOrderCronJob.setDeliveryAddress(userService.getCurrentUser().getDefaultShipmentAddress());
cartToOrderCronJob.setPaymentAddress(userService.getCurrentUser().getDefaultPaymentAddress());
cartToOrderCronJob.setPaymentInfo(cartService.getSessionCart().getPaymentInfo());
setCronJobToTrigger(cartToOrderCronJob, Collections.singletonList(triggerModel));
cartToOrderCronJob.setJob(cronJobService.getJob("b2bAcceleratorCartToOrderJob"));
modelService.save(cartToOrderCronJob);
final BaseSiteModel site = baseSiteService.getBaseSiteForUID("b2bstoretemplate");
Assert.assertNotNull("no site found for id 'site'", site);
baseSiteService.setCurrentBaseSite(site, false);
}
protected OrderModel placeTestOrder(final boolean valid)
throws InvalidCartException, CalculationException {
final CartModel cart = cartService.getSessionCart();
final UserModel user = userService.getCurrentUser();
cartService.addNewEntry(cart, productService.getProductForCode("testProduct1"), 1, null);
cartService.addNewEntry(cart, productService.getProductForCode("testProduct2"), 2, null);
cartService.addNewEntry(cart, productService.getProductForCode("testProduct3"), 3, null);
final AddressModel deliveryAddress = new AddressModel();
deliveryAddress.setOwner(user);
deliveryAddress.setFirstname("Der");
deliveryAddress.setLastname("Buck");
deliveryAddress.setTown("Muenchen");
deliveryAddress.setCountry(commonI18NService.getCountry("DE"));
modelService.save(deliveryAddress);
final DebitPaymentInfoModel paymentInfo = new DebitPaymentInfoModel();
paymentInfo.setOwner(cart);
paymentInfo.setBank("MeineBank");
paymentInfo.setUser(user);
paymentInfo.setAccountNumber("34434");
paymentInfo.setBankIDNumber("1111112");
paymentInfo.setBaOwner("Ich");
paymentInfo.setCode("testPaymentInfo1");
modelService.save(paymentInfo);
cart.setDeliveryMode(deliveryService.getDeliveryModeForCode("free"));
cart.setDeliveryAddress(deliveryAddress);
cart.setPaymentInfo(paymentInfo);
final CardInfo card = new CardInfo();
card.setCardType(CreditCardType.VISA);
card.setCardNumber("4111111111111111");
card.setExpirationMonth(Integer.valueOf(12));
if (valid) {
card.setExpirationYear(Integer.valueOf(Calendar.getInstance().get(Calendar.YEAR) + 2));
} else {
card.setExpirationYear(Integer.valueOf(Calendar.getInstance().get(Calendar.YEAR) - 2));
}
final PaymentTransactionModel paymentTransaction =
paymentService
.authorize(
"code4" + codeNo++,
BigDecimal.ONE,
Currency.getInstance("EUR"),
deliveryAddress,
deliveryAddress,
card)
.getPaymentTransaction();
cart.setPaymentTransactions(Collections.singletonList(paymentTransaction));
modelService.save(cart);
calculationService.calculate(cart);
final CommerceCheckoutParameter parameter = new CommerceCheckoutParameter();
parameter.setEnableHooks(true);
parameter.setCart(cart);
parameter.setSalesApplication(SalesApplication.WEB);
return commerceCheckoutService.placeOrder(parameter).getOrder();
}
/**
* This method retrieves the EnergizerB2BUnitModel of the currently logged in user.
*
* @see EnergizerB2BUnitModel
* @return EnergizerB2BUnitModel
*/
private EnergizerB2BUnitModel getB2BUnitForLoggedInUser() {
return b2bUserService.getParentUnitForCustomer(userService.getCurrentUser().getUid());
}