@Test(groups = { "getOrdersForCustomer" }, dependsOnGroups = { "readCustomer", "findCurrentCartForCustomer" }) @Transactional public void getOrdersForCustomer() { String username = "customer1"; Customer customer = customerService.readCustomerByUsername(username); List<Order> orders = orderService.findOrdersForCustomer(customer); assert orders != null; assert orders.size() > 0; }
@BeforeMethod(alwaysRun = true, dependsOnMethods = "springTestContextBeforeTestMethod") protected void setupCustomerId(Method testMethod) throws Exception { userId = customerService.readCustomerByUsername("customer1").getId(); }
/** * Validates that a Customer does not have their username duplicated * * @param entity * @param adminInstance * @return the original entity with a validation error on it or null if no validation failure */ protected Entity validateUniqueUsername(Entity entity, Customer adminInstance, boolean isAdd) { String email = entity.findProperty("emailAddress").getValue(); boolean skipUsernameCheck = !isAdd && StringUtils.equals(email, adminInstance.getEmailAddress()); if (!skipUsernameCheck && customerService.readCustomerByUsername(email) != null) { entity.addValidationError("emailAddress", "nonUniqueUsernameError"); return entity; } return null; }
@Override public void execute(WebRequest request, Authentication authResult) { Customer loggedInCustomer = customerService.readCustomerByUsername(authResult.getName()); Customer anonymousCustomer = customerStateRequestProcessor.getAnonymousCustomer(request); Order cart = null; if (anonymousCustomer != null) { cart = orderService.findCartForCustomer(anonymousCustomer); } MergeCartResponse mergeCartResponse; try { mergeCartResponse = mergeCartService.mergeCart(loggedInCustomer, cart); } catch (PricingException e) { throw new RuntimeException(e); } catch (RemoveFromCartException e) { throw new RuntimeException(e); } if (BLCRequestUtils.isOKtoUseSession(request)) { request.setAttribute(mergeCartResponseKey, mergeCartResponse, WebRequest.SCOPE_GLOBAL_SESSION); } }
@Test(groups = { "readOrdersForCustomer" }, dependsOnGroups = { "readCustomer", "createOrder" }) @Transactional public void readOrdersForCustomer() { userName = "customer1"; Customer user = customerService.readCustomerByUsername(userName); List<Order> orders = orderDao.readOrdersForCustomer(user.getId()); assert orders.size() > 0; }
@Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException, DataAccessException { Customer customer = customerService.readCustomerByUsername(username, false); if (customer == null) { throw new UsernameNotFoundException("The customer was not found"); } boolean isActive = !customer.isDeactivated(); if (Status.class.isAssignableFrom(customer.getClass())) { isActive = isActive && ((Status) customer).isActive(); } List<GrantedAuthority> grantedAuthorities = createGrantedAuthorities(roleService.findCustomerRolesByCustomerId(customer.getId())); return new CustomerUserDetails(customer.getId(), username, customer.getPassword(), isActive, true, !customer.isPasswordChangeRequired(), true, grantedAuthorities); }
@Test(groups = { "changeCustomerPassword" }, dependsOnGroups = { "readCustomer" }) @Transactional @Commit public void changeCustomerPasswords() { for (String userName : userNames) { Customer customer = customerService.readCustomerByUsername(userName); customer.setPassword(customer.getPassword() + "-Changed"); customerService.saveCustomer(customer); } }
@Test(groups = { "createCartForCustomer" }, dependsOnGroups = { "readCustomer", "createPhone" }) @Transactional @Rollback(false) public void createCartForCustomer() { String userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); Order order = orderService.createNewCartForCustomer(customer); assert order != null; assert order.getId() != null; this.orderId = order.getId(); }
@Test(groups = { "findCurrentCartForCustomer" }, dependsOnGroups = { "readCustomer", "createPhone", "createCartForCustomer" }) @Transactional @Rollback(false) public void findCurrentCartForCustomer() { String userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); Order order = orderService.findCartForCustomer(customer); assert order != null; assert order.getId() != null; this.orderId = order.getId(); }
@Test(groups = { "createOrder" }, dataProvider = "basicOrder", dataProviderClass = OrderDataProvider.class, dependsOnGroups = { "readCustomer", "createPhone" }) @Rollback(false) @Transactional public void createOrder(Order order) { userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); assert order.getId() == null; order.setCustomer(customer); order = orderDao.save(order); assert order.getId() != null; orderId = order.getId(); }
@Test(groups = "viewExistingCustomerPhoneFromController", dependsOnGroups = "createCustomerPhoneFromController") @Transactional public void viewExistingCustomerPhoneFromController() { List<CustomerPhone> phones_1 = customerPhoneService.readAllCustomerPhonesByCustomerId(userId); PhoneNameForm pnf = new PhoneNameForm(); BindingResult errors = new BeanPropertyBindingResult(pnf, "phoneNameForm"); Customer customer = customerService.readCustomerByUsername("customer1"); request = this.getNewServletInstance(); request.setAttribute(CustomerStateRequestProcessor.getCustomerRequestAttributeName(), customer); String view = customerPhoneController.viewPhone(phones_1.get(0).getId(), request, pnf, errors); assert (view.indexOf(SUCCESS) >= 0); assert (request.getAttribute("customerPhoneId").equals(phones_1.get(0).getId())); }
@Test(groups = "createCustomerFromController", dataProvider = "setupCustomerControllerData", dataProviderClass = RegisterCustomerDataProvider.class, enabled=false) @Transactional @Rollback(false) public void createCustomerFromController(RegisterCustomerForm registerCustomer) { BindingResult errors = new BeanPropertyBindingResult(registerCustomer, "registerCustomer"); MockHttpServletRequest request = new MockHttpServletRequest(); MockHttpServletResponse response = new MockHttpServletResponse(); registerCustomerController.registerCustomer(registerCustomer, errors, request, response); assert(errors.getErrorCount() == 0); Customer customerFromDb = customerService.readCustomerByUsername(registerCustomer.getCustomer().getUsername()); assert(customerFromDb != null); }
@Test(groups = "createCustomerPhone", dataProvider = "setupCustomerPhone", dataProviderClass = CustomerPhoneDataProvider.class, dependsOnGroups = "readCustomer") @Transactional @Rollback(false) public void createCustomerPhone(CustomerPhone customerPhone) { userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); assert customerPhone.getId() == null; customerPhone.setCustomer(customer); Phone phone = new PhoneImpl(); phone.setPhoneNumber("214-214-2134"); customerPhone.setPhone(phone); customerPhone = customerPhoneService.saveCustomerPhone(customerPhone); assert customer.equals(customerPhone.getCustomer()); userId = customerPhone.getCustomer().getId(); }
@Test(groups={"createPaymentInfo"}, dataProvider="basicPaymentInfo", dataProviderClass=PaymentInfoDataProvider.class, dependsOnGroups={"readCustomer", "createOrder"}) @Rollback(false) @Transactional public void createPayment(OrderPayment payment){ userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); List<CustomerAddress> addresses = customerAddressDao.readActiveCustomerAddressesByCustomerId(customer.getId()); Address address = null; if (!addresses.isEmpty()) address = addresses.get(0).getAddress(); Order salesOrder = orderService.createNewCartForCustomer(customer); payment.setBillingAddress(address); payment.setOrder(salesOrder); payment.setType(PaymentType.CREDIT_CARD); assert payment.getId() == null; payment = paymentInfoService.save(payment); assert payment.getId() != null; this.paymentInfo = payment; }
@Test(groups = "createCustomerPhoneFromController", dataProvider = "setupCustomerPhoneControllerData", dataProviderClass = CustomerPhoneControllerTestDataProvider.class, dependsOnGroups = "readCustomer") @Transactional @Commit public void createCustomerPhoneFromController(PhoneNameForm phoneNameForm) { BindingResult errors = new BeanPropertyBindingResult(phoneNameForm, "phoneNameForm"); Customer customer = customerService.readCustomerByUsername("customer1"); request = this.getNewServletInstance(); request.setAttribute(CustomerStateRequestProcessor.getCustomerRequestAttributeName(), customer); String view = customerPhoneController.savePhone(phoneNameForm, errors, request, null, null); assert (view.indexOf(SUCCESS) >= 0); List<CustomerPhone> phones = customerPhoneService.readAllCustomerPhonesByCustomerId(userId); boolean inPhoneList = false; Long id = (Long) request.getAttribute("customerPhoneId"); assert (id != null); for (CustomerPhone p : phones) { if ((p.getPhoneName() != null) && p.getPhoneName().equals(phoneNameForm.getPhoneName())) { inPhoneList = true; } } assert (inPhoneList == true); createdCustomerPhoneIds.add(id); }
@Override public Entity update(PersistencePackage persistencePackage, DynamicEntityDao dynamicEntityDao, RecordHelper helper) throws ServiceException { Entity entity = persistencePackage.getEntity(); Customer customer = customerService.readCustomerByUsername(entity.findProperty("username").getValue()); if (StringUtils.isEmpty(customer.getEmailAddress())) { throw new ServiceException("Unable to update password because an email address is not available for this customer. An email address is required to send the customer the new system generated password."); } PasswordReset passwordReset = new PasswordReset(); passwordReset.setUsername(entity.findProperty("username").getValue()); passwordReset.setPasswordChangeRequired(false); passwordReset.setEmail(customer.getEmailAddress()); passwordReset.setPasswordLength(22); passwordReset.setSendResetEmailReliableAsync(false); customer = customerService.resetPassword(passwordReset); return entity; }
@Test(groups={"testCreatePaymentInfo"}, dependsOnGroups={"createPaymentInfo"}) @Transactional public void createTestPayment(){ userName = "customer1"; OrderPayment paymentInfo = paymentInfoService.create(); Customer customer = customerService.readCustomerByUsername(userName); List<CustomerAddress> addresses = customerAddressDao.readActiveCustomerAddressesByCustomerId(customer.getId()); Address address = null; if (!addresses.isEmpty()) address = addresses.get(0).getAddress(); Order salesOrder = orderService.findCartForCustomer(customer); paymentInfo.setBillingAddress(address); paymentInfo.setOrder(salesOrder); paymentInfo.setType(PaymentType.CREDIT_CARD); assert paymentInfo != null; paymentInfo = paymentInfoService.save(paymentInfo); assert paymentInfo.getId() != null; Long paymentInfoId = paymentInfo.getId(); paymentInfoService.delete(paymentInfo); paymentInfo = paymentInfoService.readPaymentById(paymentInfoId); assert paymentInfo == null; }
@Test(groups = { "checkout" }, dependsOnGroups = { "createCartForCustomer", "testShippingInsert" }, dataProvider = "USCurrency", dataProviderClass = BroadleafCurrencyProvider.class) @Transactional public void testCheckout(BroadleafCurrency usCurrency) throws Exception { HashMap currencyConsiderationContext = new HashMap(); currencyConsiderationContext.put("aa","bb"); CurrencyConversionContext.setCurrencyConversionContext(currencyConsiderationContext); CurrencyConversionContext.setCurrencyConversionService(new CurrencyConversionService() { @Override public Money convertCurrency(Money source, Currency destinationCurrency, int destinationScale) { return source; } }); String userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); Order order = orderService.createNewCartForCustomer(customer); usCurrency = currencyService.save(usCurrency); order.setCurrency(usCurrency); Address address = buildAddress(); FulfillmentGroup group = buildFulfillmentGroup(order, address); addSampleItemToOrder(order, group); order.setTotalShipping(new Money(0D)); addPaymentToOrder(order, address); //execute pricing for this order orderService.save(order, true); CheckoutResponse response = checkoutService.performCheckout(order); assert (order.getTotal().greaterThan(order.getSubTotal())); }
/** * This method only exists because so many other tests depend on it, but should be removed once tests are more isolated * @param customerAddress */ @Deprecated @Test(groups = "createCustomerAddress", dataProvider = "setupCustomerAddress", dataProviderClass = CustomerAddressDataProvider.class, dependsOnGroups = {"readCustomer", "createCountry", "createState"}) @Transactional @Rollback(false) public void createCustomerAddress(CustomerAddress customerAddress) { userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); assert customerAddress.getId() == null; customerAddress.setCustomer(customer); State state = stateService.findStateByAbbreviation("KY"); customerAddress.getAddress().setState(state); Country country = countryService.findCountryByAbbreviation("US"); customerAddress.getAddress().setCountry(country); customerAddress.getAddress().setIsoCountrySubdivision("US-KY"); ISOCountry isoCountry = isoService.findISOCountryByAlpha2Code("US"); customerAddress.getAddress().setIsoCountryAlpha2(isoCountry); customerAddress = customerAddressService.saveCustomerAddress(customerAddress); assert customer.equals(customerAddress.getCustomer()); userId = customerAddress.getCustomer().getId(); }
@Test(groups = "createItemFulfillmentGroup", dataProvider = "basicFulfillmentGroup", dataProviderClass = FulfillmentGroupDataProvider.class, dependsOnGroups = { "createOrder", "createCustomerAddress" }) @Rollback(false) @Transactional public void createDefaultFulfillmentGroup(FulfillmentGroup fulfillmentGroup) { String userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); Address address = (customerAddressDao.readActiveCustomerAddressesByCustomerId(customer.getId())).get(0).getAddress(); salesOrder = orderDao.createNewCartForCustomer(customer); FulfillmentGroup newFG = fulfillmentGroupDao.createDefault(); newFG.setAddress(address); newFG.setRetailShippingPrice(fulfillmentGroup.getRetailShippingPrice()); newFG.setMethod(fulfillmentGroup.getMethod()); newFG.setService(fulfillmentGroup.getService()); newFG.setOrder(salesOrder); newFG.setReferenceNumber(fulfillmentGroup.getReferenceNumber()); assert newFG.getId() == null; this.fulfillmentGroup = fulfillmentGroupService.save(newFG); assert this.fulfillmentGroup.getId() != null; }