@Before
public void setUp() throws Exception {
createCoreData();
createDefaultUsers();
createDefaultCatalog();
product1 = productService.getProductForCode("testProduct1");
product2 = productService.getProductForCode("testProduct2");
product3 = productService.getProductForCode("testProduct3");
product4 = productService.getProductForCode("testProduct4");
}
@Test
public void testRemoveFromCollection() {
final UserModel user = userService.getUserForUID("ahertz");
List<CockpitObjectAbstractCollectionModel> collections =
cockpitCollectionService.getCollectionsForUser(user);
CockpitObjectAbstractCollectionModel collection = null;
for (final CockpitObjectAbstractCollectionModel coll : collections) {
if ("testA".equals(coll.getQualifier())) {
collection = coll;
break;
}
}
assertThat(collection.getElements().size()).isEqualTo(2);
final CatalogVersionModel catalogVersion =
catalogService.getCatalogVersion("testCatalog", "Online");
final List<ItemModel> elements = new ArrayList<ItemModel>();
elements.add(productService.getProductForCode(catalogVersion, "testProduct4"));
int n = cockpitCollectionService.removeFromCollection(collection, elements);
collections = cockpitCollectionService.getCollectionsForUser(user);
CockpitObjectAbstractCollectionModel changedCollection = null;
for (final CockpitObjectAbstractCollectionModel coll : collections) {
if ("testA".equals(coll.getQualifier())) {
changedCollection = coll;
break;
}
}
// should not change, before we tried to remove the element that does not exist in the
// collection
assertThat(changedCollection.getElements().size()).isEqualTo(2);
assertThat(n).isEqualTo(0);
elements.clear();
elements.add(productService.getProductForCode(catalogVersion, "testProduct0"));
n = cockpitCollectionService.removeFromCollection(collection, elements);
collections = cockpitCollectionService.getCollectionsForUser(user);
changedCollection = null;
for (final CockpitObjectAbstractCollectionModel coll : collections) {
if ("testA".equals(coll.getQualifier())) {
changedCollection = coll;
break;
}
}
assertThat(changedCollection.getElements().size()).isEqualTo(1);
assertThat(n).isEqualTo(1);
}
@Override
@Before
public void setUp() throws Exception {
super.setUp();
final CatalogVersionModel version =
catalogVersionService.getCatalogVersion("hwcatalog", "Online");
catalogVersionService.addSessionCatalogVersion(version);
baseProduct = productService.getProductForCode(version, "HW2110-0019");
partnerProduct = productService.getProductForCode(version, "HW2200-0561");
user = userService.getUserForUID("demo");
userService.setCurrentUser(user);
currency = commonI18NService.getCurrency("EUR");
commonI18NService.setCurrentCurrency(currency);
}
@Test
public void testAddToCollection() {
final UserModel user = userService.getUserForUID("ahertz");
List<CockpitObjectAbstractCollectionModel> collections =
cockpitCollectionService.getCollectionsForUser(user);
CockpitObjectAbstractCollectionModel collection = null;
for (final CockpitObjectAbstractCollectionModel coll : collections) {
if ("testA".equals(coll.getQualifier())) {
collection = coll;
break;
}
}
assertThat(collection.getElements().size()).isEqualTo(2);
final CatalogVersionModel catalogVersion =
catalogService.getCatalogVersion("testCatalog", "Online");
final List<ItemModel> elements = new ArrayList<ItemModel>();
elements.add(productService.getProductForCode(catalogVersion, "testProduct4"));
final int n = cockpitCollectionService.addToCollection(collection, elements);
collections = cockpitCollectionService.getCollectionsForUser(user);
CockpitObjectAbstractCollectionModel changedCollection = null;
for (final CockpitObjectAbstractCollectionModel coll : collections) {
if ("testA".equals(coll.getQualifier())) {
changedCollection = coll;
break;
}
}
assertThat(changedCollection.getElements().size()).isEqualTo(3);
assertThat(n).isEqualTo(1);
}
private void setupProducts() {
final CatalogVersionModel catalogVersionModel =
catalogVersionService.getCatalogVersion("testCatalog", "Online");
subscriptionProduct =
(SubscriptionProductModel)
productService.getProductForCode(catalogVersionModel, SUBSCRIPTION_PRODUCT_CODE);
}
@Test
public void shouldStartApprovalProcessAndIgnoreInactiveCreditLimit() throws Exception {
final String userId = "GC S HH";
login(userId);
// Set up credit limit data for test
final B2BUnitModel unitLoggedIn = b2bUnitService.getUnitForUid("GC Sales Hamburg");
final B2BCreditLimitModel creditLimitToUse =
b2bUnitService.getParent(unitLoggedIn).getCreditLimit();
creditLimitToUse.setActive(Boolean.TRUE);
creditLimitToUse.setDateRange(B2BPeriodRange.DAY);
creditLimitToUse.setDatePeriod(null);
modelService.save(creditLimitToUse);
// Credit Limit is active, so unit is returned
final B2BUnitModel unitWithCreditLimit = b2bUnitService.getUnitWithCreditLimit(unitLoggedIn);
Assert.assertNotNull(unitWithCreditLimit);
// Update credit limit with past start/end dates as date range
final B2BCreditLimitModel creditLimit = unitWithCreditLimit.getCreditLimit();
creditLimit.setActive(Boolean.FALSE);
modelService.save(creditLimit);
// Create order which crosses credit limit
final OrderModel order =
createOrder(
this.login("GC S HH"),
140,
OrderStatus.CREATED,
productService.getProductForCode("testProduct0"));
Assert.assertNotNull(order);
final B2BApprovalProcessModel b2bApprovalProcessModel =
getB2BApprovalProcessModelForOrder(order);
// Process does not stop at waitProcessCreditLimit, so it should continue after waitProcess
if (this.waitForProcessAction(b2bApprovalProcessModel.getCode(), "waitProcess", 20000)) {
modelService.refresh(order);
final Collection<WorkflowActionModel> actions =
b2bWorkflowIntegrationService.getStartWorkflowActions(order.getWorkflow());
Assert.assertEquals(1, actions.size());
b2bWorkflowIntegrationService.approveWorkflowAction(actions.iterator().next());
}
// Credit limit is inactive, so unit is null
final B2BUnitModel unitWithCreditLimitNull =
b2bUnitService.getUnitWithCreditLimit(order.getUnit());
Assert.assertNull(unitWithCreditLimitNull);
// Process finishes and order placed above is approved - Order total is more than credit limit
// amount, but
// credit limit is inactive, so its ignored
this.waitForProcessToEnd(b2bApprovalProcessModel.getCode(), 20000);
this.modelService.refresh(order);
this.modelService.refresh(b2bApprovalProcessModel);
Assert.assertEquals(OrderStatus.APPROVED, order.getStatus());
Assert.assertEquals(ProcessState.SUCCEEDED, b2bApprovalProcessModel.getProcessState());
}
private OrderEntryModel createTestOrderEntry(final OrderModel order) {
final OrderEntryModel entry1 = modelService.create(OrderEntryModel.class);
entry1.setOrder(order);
entry1.setQuantity(Long.valueOf(1));
entry1.setUnit(productService.getOrderableUnit(product1));
entry1.setProduct(product1);
return entry1;
}
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;
}
private void prepareData() {
catVersion = catalogVersionService.getCatalogVersion("hwcatalog", "Online");
catalogVersionService.addSessionCatalogVersion(catVersion);
user = userService.getUserForUID("ariel");
userService.setCurrentUser(user);
cart = cartService.getSessionCart();
commonI18NService.setCurrentCurrency(commonI18NService.getCurrency("EUR"));
product1 = productService.getProductForCode(catVersion, "HW2110-0012");
}
@Before
public void setUp() throws Exception {
// final Create data for tests
LOG.info("Creating data for DefaultChangeProductPriceBundleRuleDaoIntegrationTest ..");
userService.setCurrentUser(userService.getAdminUser());
final long startTime = System.currentTimeMillis();
new CoreBasicDataCreator().createEssentialData(Collections.EMPTY_MAP, null);
// importing test csv
final String legacyModeBackup = Config.getParameter(ImpExConstants.Params.LEGACY_MODE_KEY);
LOG.info(
"Existing value for " + ImpExConstants.Params.LEGACY_MODE_KEY + " :" + legacyModeBackup);
Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, "true");
importCsv("/commerceservices/test/testCommerceCart.csv", "utf-8");
Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, "false");
importCsv("/subscriptionservices/test/testSubscriptionCommerceCartService.impex", "utf-8");
importCsv("/configurablebundleservices/test/testBundleCommerceCartService.impex", "utf-8");
importCsv("/configurablebundleservices/test/testApproveAllBundleTemplates.impex", "utf-8");
Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, legacyModeBackup);
LOG.info(
"Finished data for DefaultChangeProductPriceBundleRuleDaoIntegrationTest "
+ (System.currentTimeMillis() - startTime)
+ "ms");
baseSiteService.setCurrentBaseSite(baseSiteService.getBaseSiteForUID(TEST_BASESITE_UID), false);
catalogVersionService.setSessionCatalogVersion("testCatalog", "Online");
currencyUSD = commonI18NService.getCurrency("USD");
currencyEUR = commonI18NService.getCurrency("EUR");
galaxynexus = productService.getProductForCode("GALAXY_NEXUS");
standardplan1y = productService.getProductForCode("PLAN_STANDARD_1Y");
standardplan3y = productService.getProductForCode("PLAN_STANDARD_3Y");
smartPhonePlanBundleTemplate =
bundleTemplateService.getBundleTemplateForCode("SmartPhonePlanSelection");
smartPhoneDeviceBundleTemplate =
bundleTemplateService.getBundleTemplateForCode("SmartPhoneDeviceSelection");
modelService.detachAll();
}
@Test
public void shouldStartApprovalProcessAndAssertApprovalFromMerchant() throws Exception {
login("GC S HH");
// Set up credit limit data for test
final B2BUnitModel unitLoggedIn = b2bUnitService.getUnitForUid("GC Sales Hamburg");
final B2BCreditLimitModel creditLimitToUse =
b2bUnitService.getParent(unitLoggedIn).getCreditLimit();
creditLimitToUse.setActive(Boolean.TRUE);
creditLimitToUse.setDateRange(B2BPeriodRange.DAY);
creditLimitToUse.setDatePeriod(null);
modelService.save(creditLimitToUse);
final OrderModel order =
createOrder(
this.login("GC S HH"),
140,
OrderStatus.CREATED,
productService.getProductForCode("testProduct0"));
Assert.assertNotNull(order);
final B2BApprovalProcessModel b2bApprovalProcessModel =
getB2BApprovalProcessModelForOrder(order);
final B2BUnitModel unitWithCreditLimit = b2bUnitService.getUnitWithCreditLimit(order.getUnit());
Assert.assertEquals("GC Sales DE", unitWithCreditLimit.getUid());
if (this.waitForProcessAction(b2bApprovalProcessModel.getCode(), "waitProcess", 20000)) {
modelService.refresh(order);
final Collection<WorkflowActionModel> actions =
b2bWorkflowIntegrationService.getStartWorkflowActions(order.getWorkflow());
Assert.assertEquals(1, actions.size());
b2bWorkflowIntegrationService.decideAction(
actions.iterator().next(), B2BWorkflowIntegrationService.DECISIONCODES.APPROVE.name());
}
if (this.waitForProcessAction(
b2bApprovalProcessModel.getCode(), "waitProcessCreditLimit", 20000)) {
modelService.refresh(order);
final Collection<WorkflowActionModel> actions =
b2bWorkflowIntegrationService.getStartWorkflowActions(order.getWorkflow());
Assert.assertEquals(1, actions.size());
this.approveWorkflowAction(actions.iterator().next());
}
this.waitForProcessToEnd(b2bApprovalProcessModel.getCode(), 20000);
this.modelService.refresh(order);
this.modelService.refresh(b2bApprovalProcessModel);
Assert.assertEquals(OrderStatus.APPROVED, order.getStatus());
Assert.assertEquals(ProcessState.SUCCEEDED, b2bApprovalProcessModel.getProcessState());
}
@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));
}
/**
* Tests promotion with voucher that has product restriction. (currency is Euro)
*
* <ul>
* <li>product(HW1230-0001) price = 769.00 --> 2x = 1538.00
* <li>product(HW2110-0012) price = 81.08 --> 2x = 162.16
* <li>so the cart contains products that cost 1700.16 Euro without promotion/voucher.
* <li>redeems the voucher that is 10% discount with product restriction: only valid for
* [HW1230-0001]
* <li>applies the fixed price promotion that is only valid for [HW1230-0001], and the fixed
* price is 500
* <li>update promotions, and the total discount should be (500 * 2) * 10% = 100
* <li>total price of the cart: (500 * 2 + 81.08 * 2) - 100 = 1062.16
* </ul>
*/
@Test
public void testPromotionWithProductRestrictionVoucher()
throws CalculationException, JaloPriceFactoryException {
// PRO-70
promotionGroup = promotionsService.getPromotionGroup("prGroup20");
final ProductModel productSony = productService.getProductForCode(catVersion, "HW1230-0001");
cartService.addNewEntry(cart, productSony, 2, productSony.getUnit());
cartService.addNewEntry(cart, product1, 2, product1.getUnit());
modelService.save(cart);
calculationService.calculate(cart);
modelService.refresh(cart);
assertEquals(
"should be 1700.16 euro without promotion/voucher",
1700.16,
cart.getTotalPrice().doubleValue(),
0.01);
voucherService.redeemVoucher(restrictionProductVoucher, cart);
modelService.save(cart);
final List<PromotionGroupModel> groups = new ArrayList<PromotionGroupModel>();
groups.add(promotionGroup);
promotionsService.updatePromotions(
groups,
cart,
false,
AutoApplyMode.APPLY_ALL,
AutoApplyMode.APPLY_ALL,
new java.util.Date());
modelService.refresh(cart);
assertEquals(
"should be 100 euro for fixed price discount",
100.0,
cart.getTotalDiscounts().doubleValue(),
0.01);
assertEquals(
"should be 1062.16 euro for total", 1062.16, cart.getTotalPrice().doubleValue(), 0.01);
}
protected ProductModel processFile(
final Long productId, final String filePrefix, final FileContent content)
throws Exception // NOPMD
{
File file = null;
BatchHeader header = null;
try {
file = File.createTempFile(filePrefix, ".csv");
header = createHeader(file);
createFile(file, productId, content);
batchTransformerTask.execute(header);
batchRunnerTask.execute(header);
return productService.getProductForCode(productId.toString());
} finally {
if (file != null) {
file.delete();
}
if (header != null) {
header.setFile(null);
batchCleanupTask.execute(header);
}
}
}
@Test
public void testVariant() throws Exception {
processFile(
productId,
"base_product-",
new ProductContent() {
@Override
public void writeContent(final PrintWriter writer) throws IOException {
writer.print("ApparelSizeVariantProduct");
super.writeContent(writer);
}
});
final Long variantId = Long.valueOf(Math.abs((long) random.nextInt()));
final ProductModel product =
processFile(
productId,
"variant-",
new FileContent() {
@Override
public void writeContent(final PrintWriter writer) throws IOException {
writer.print(variantId);
writer.print(SEPARATOR);
writer.print(SEPARATOR);
writer.print("black");
writer.print(SEPARATOR);
writer.print("L");
}
});
final ApparelSizeVariantProductModel variant =
(ApparelSizeVariantProductModel) productService.getProductForCode(variantId.toString());
Assert.assertEquals("ApparelSizeVariantProduct", product.getVariantType().getCode());
Assert.assertEquals(product, variant.getBaseProduct());
Assert.assertEquals("black", variant.getStyle(Locale.ENGLISH));
Assert.assertNull(variant.getStyle(Locale.GERMAN));
Assert.assertEquals("L", variant.getSize(Locale.ENGLISH));
Assert.assertNull(variant.getSize(Locale.GERMAN));
}
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();
}