@Test
  public void testNeverTransactionalShouldPassThrough() {
    customerService.cleanDatabase();
    roleService.cleanDatabase();
    try {

      // customer is wrong - it is going to be exception
      customerService.createCustomerComplexInsideNevetTrans_NoTransOutside(
          customerWithTooLongCity, okRole);
    } catch (Exception e) {
      Integer addressVol = customerDAO.getAddressVol();
      Integer personVol = customerDAO.getPersonVol();
      Integer roleVol = roleDAO.getRolesVol();

      // records created by insertCustomer method - no transactional so address is created and
      // commited and then exception and rollback on person
      assertEquals(new Integer(0), addressVol);
      assertEquals(new Integer(1), personVol);

      // record created by createRoleNeverTransaction method - no transactional so role is commited
      // - as a first line of execution inside
      // customerService.createCustomerComplexInsideNevetTrans_NoTransOutside method
      assertEquals(new Integer(1), roleVol);
    }
  }
  @Test
  @Transactional
  public void shouldNotCreateAddressInSecondCustomer() {
    customerService.cleanDatabase();
    roleService.cleanDatabase();
    try {
      // first customer is ok, second has wrong data too long address name so there will be
      // exception
      customerService.createCustomerComplexProxyBasedExample(okCustomer, customerWithTooLongCity);
    } catch (Exception e) {
      Integer addressVol = customerDAO.getAddressVol();
      Integer personVol = customerDAO.getPersonVol();
      System.out.println("Address vol =" + addressVol + " personVol=" + personVol);
      // first person from okCustomer, second person from customerWithTooLongCity
      assertEquals(new Integer(2), personVol);
      // first address from okCustomer, second not exists because of exception and rollback in this
      // step
      assertEquals(new Integer(1), addressVol);

      /**
       * This assertion shows that in second customer creation there is no transactional because
       * person was created - only addres was rolledback
       */
    }
  }
 /**
  * In this case exception because outside were created transaction and inside transaction is not
  * allowed
  */
 @Test(expected = IllegalTransactionStateException.class)
 public void testNeverTransactionalShouldThrowException() {
   customerService.cleanDatabase();
   roleService.cleanDatabase();
   // customer is wrong - it is going to be exception
   customerService.createCustomerComplexInsideNevetTrans_WithTransOutside(
       customerWithTooLongCity, okRole);
 }
Exemplo n.º 4
0
  @Test
  public void testStoreCustomer() {

    when(customerRepository.save(customer)).thenReturn(customer);

    customerService.storeCustomer(customer);
  }
Exemplo n.º 5
0
 @Test
 public void testCreateCustomer() {
   Customer customer = new Customer();
   FullName fullName = new FullName();
   fullName.setFirstName("test");
   fullName.setMiddleName("test");
   fullName.setSurName("test");
   customer.setFullName(fullName);
   customer.setCreditRating(80);
   customer.setInitials("S");
   customer.setMaritalStatus(MaritalStatus.valueOf("MARRIED"));
   customer.setNabCustomer(true);
   Address address = new Address();
   address.setStreetNumber(12);
   address.setStreetName("test");
   address.setSuburb("test");
   address.setCity("test");
   address.setState("test");
   address.setPincode(3166);
   address.setCountry("test");
   customer.setResidenceAddress(address);
   customer.setSex(Sex.valueOf("MALE"));
   customer.setTitle("Mr");
   assert (customerService.createCustomer(customer));
 }
Exemplo n.º 6
0
  public static void main(String... args) {
    ApplicationContext applicationContext =
        new ClassPathXmlApplicationContext("applicationContext.xml");
    CustomerService customerService =
        (CustomerService) applicationContext.getBean("customerServiceProxy");
    customerService.printName();
    customerService.printURL();
    try {
      customerService.printThrowException();
    } catch (Exception e) {

    } finally {
      if (applicationContext != null) {
        ((ClassPathXmlApplicationContext) applicationContext).close();
      }
    }
  }
  @Test
  public void testCreateCustomer() {
    Customer cust = new Customer();
    cust.setId(1L);

    service.createCustomer(cust);
    verify(customerDaoMock).create(cust);
    verifyNoMoreInteractions(customerDaoMock);
  }
Exemplo n.º 8
0
  @Test
  public void testFindAll() {

    List<Customer> customers = new ArrayList<Customer>();
    customers.add(customer);

    when(customerRepository.findAll()).thenReturn(customers);

    assertEquals(1, customerService.findAll().size());
  }
  @Test
  public void testFindCustomerById() {
    Customer c1 = new Customer();
    c1.setId(1L);
    doReturn(c1).when(customerDaoMock).findById(1L);

    Customer customer = service.findCustomerById(1L);
    verify(customerDaoMock).findById(1L);
    verifyNoMoreInteractions(customerDaoMock);
    Assert.assertEquals(Long.valueOf(1), customer.getId());
  }
  @Test
  public void testDeleteCustomer() {
    Customer c1 = new Customer();
    c1.setId(1L);
    doReturn(c1).when(customerDaoMock).findById(1L);

    service.deleteCustomer(1L);
    verify(customerDaoMock).findById(1L);
    verify(customerDaoMock).remove(c1);
    verifyNoMoreInteractions(customerDaoMock);
  }
  /**
   * Please compare it with test shouldNotCreateAddressInSecondCustomer(). Here you can see that
   * inside body executed method are transactional. Creation second customer is transactional, so
   * when rollback is executed in second step then whole actions inside
   * createCustomerComplexProxyBasedExampleAllTransactional() are rolledback
   */
  @Test
  @Transactional
  public void shouldNotCreateAnyItemsDuringExecution() {
    customerService.cleanDatabase();
    roleService.cleanDatabase();
    try {
      // first customer is ok, second has wrong data (too long city), rollback is executed in second
      // step
      // here whole method is rolledback
      customerService.createCustomerComplexProxyBasedExampleAllTransactional(
          okCustomer, customerWithTooLongCity);
    } catch (Exception e) {

      Integer addressVol = customerDAO.getAddressVol();
      Integer personVol = customerDAO.getPersonVol();

      assertEquals(new Integer(0), personVol);
      assertEquals(new Integer(0), addressVol);
    }
  }
 public Order criarPedido(Order pedido, String emailCliente, String senhaCliente)
     throws CustomerNotFoundException {
   Customer cliente = clienteServices.findByEmailAndSenha(emailCliente, senhaCliente);
   if (cliente == null) {
     throw new CustomerNotFoundException();
   }
   pedido.setData(new Date());
   pedido.setCliente(cliente);
   em.persist(pedido);
   return pedido;
 }
  @Test
  public void testFindCustomerByEmail() {
    Customer c1 = new Customer();
    String email = "*****@*****.**";
    c1.setEmail(email);
    doReturn(c1).when(customerDaoMock).findByEmail(email);

    Customer customer = service.findCustomerByEmail(email);
    verify(customerDaoMock).findByEmail(email);
    verifyNoMoreInteractions(customerDaoMock);
    Assert.assertEquals(email, customer.getEmail());
  }
 /**
  * In this example method is not transactional
  *
  * @throws Exception
  */
 @Test
 public void shouldRollbackOnlyAddress() throws Exception {
   try {
     // customer is wrong - it is going to be exception
     customerService.createCustomerNoTransactional(customerWithTooLongCity);
   } catch (Exception e) {
     Integer addressVol = customerDAO.getAddressVol();
     Integer personVol = customerDAO.getPersonVol();
     assertEquals(new Integer(0), addressVol);
     assertEquals(new Integer(1), personVol);
   }
 }
Exemplo n.º 15
0
  public TravelOffice() {
    MailServiceImpl mailServiceImpl = new MailServiceImpl();
    mailServiceImpl.setSmtpHost("test");
    mailServiceImpl.setSmtpPass("test");
    mailServiceImpl.setUseSSL(true);
    mailServiceImpl.setSmtpUser("tets");
    mailService = mailServiceImpl;

    newsletterService = new NewsletterServiceImpl(customerService, tripService, mailService);

    customerService.loadFromXml();
  }
  /**
   * In this example there is transaction during execution createCustomerComplexInsideSupport_Trans,
   * exception is thrown during customer creation
   */
  @Test
  public void shouldRollbackAllCreationRoleAddressAndPerson() {
    customerService.cleanDatabase();
    roleService.cleanDatabase();
    try {
      // customer is wrong - it is going to be exception - first roles are created
      customerService.createCustomerComplexInsideSupport_WithTransOutside(
          customerWithTooLongCity, okRole);
    } catch (Exception e) {
      Integer addressVol = customerDAO.getAddressVol();
      Integer personVol = customerDAO.getPersonVol();
      Integer roleVol = roleDAO.getRolesVol();

      // records created by insertCustomer method
      assertEquals(new Integer(0), addressVol);
      assertEquals(new Integer(0), personVol);

      // record created by createRoleTransactionSupport method
      assertEquals(new Integer(0), roleVol);
    }
  }
Exemplo n.º 17
0
  @Test
  public void testCanRemoveCustomer() {
    String sql = "insert into sys_user(user_name, customer_id, status) values('rgm', 99, 1)";
    this.simpleJdbcTemplate.getJdbcOperations().update(sql);

    List<CustomerBean> customers = new ArrayList<CustomerBean>();
    CustomerBean customer = new CustomerBean();
    customer.setId(99);
    customers.add(customer);
    boolean result = service.canRemoveCustomer(customers);
    Assert.assertEquals(false, result);
  }
  /**
   * Exception is thrown during customer creation, no transation and no support transaction inside
   * role creation
   */
  @Test
  public void shouldCreatePersonAndRolesButNoAddress() {
    customerService.cleanDatabase();
    roleService.cleanDatabase();
    try {
      // customer is wrong - it is going to be exception
      customerService.createCustomerComplexInsideNotSupported_NoTransOutside(
          customerWithTooLongCity, okRole);
    } catch (Exception e) {
      Integer addressVol = customerDAO.getAddressVol();
      Integer personVol = customerDAO.getPersonVol();
      Integer roleVol = roleDAO.getRolesVol();

      // records created by insertCustomer method - no transaction so executed independently but in
      // address insertion no because of exception - in this case is rollback
      assertEquals(new Integer(0), addressVol);
      assertEquals(new Integer(1), personVol);

      // record created by createRoleTransactionNotSupported method - no transaction so commited
      assertEquals(new Integer(1), roleVol);
    }
  }
  @Test
  public void testFindAllCustomers() {
    Customer c1 = new Customer();
    c1.setId(1L);
    Customer c2 = new Customer();
    c2.setId(2L);
    doReturn(toList(new Customer[] {c1, c2})).when(customerDaoMock).findAll();

    Collection<Customer> customers = service.findAllCustomers();
    verify(customerDaoMock).findAll();
    verifyNoMoreInteractions(orderDaoMock);
    Assert.assertEquals(2, customers.size());
  }
  /**
   * Exception is thrown during customer creation, no transation and no support transaction inside
   * role creation
   */
  @Test
  public void shouldCreatePersonAndRolesButNoAddress2() {
    customerService.cleanDatabase();
    roleService.cleanDatabase();
    try {
      // customer is wrong - it is going to be exception
      customerService.createCustomerComplexInsideNotSupported_WithTransOutside(
          customerWithTooLongCity, okRole);
    } catch (Exception e) {
      Integer addressVol = customerDAO.getAddressVol();
      Integer personVol = customerDAO.getPersonVol();
      Integer roleVol = roleDAO.getRolesVol();

      // records created by insertCustomer method - transactional so rollback all inserts in this
      // method, rollback because of problem during inserting address
      assertEquals(new Integer(0), addressVol);
      assertEquals(new Integer(0), personVol);

      // record created by createRoleTransactionNotSupported method - transaction is not supported
      // even if outside method is transactional - so in this example role record is commited
      assertEquals(new Integer(1), roleVol);
    }
  }
  /** In this case */
  @Test
  @Transactional
  public void shouldCreateNewTransactionForCreateRoles() {
    customerService.cleanDatabase();
    roleService.cleanDatabase();
    try {
      // customer is OK, but wrongRole has too long name
      customerService.createCustomerComplexNewRequired_NoTransOutside(
          okCustomer, okRole, wrongRole);
    } catch (Exception e) {
      Integer addressVol = customerDAO.getAddressVol();
      Integer personVol = customerDAO.getPersonVol();
      Integer roleVol = roleDAO.getRolesVol();

      // address and person are commited independently (because of no transactional) but commited
      assertEquals(new Integer(1), addressVol);
      assertEquals(new Integer(1), personVol);

      // here second role was to long and exception was thrown but bacause of transaction required
      // (and created) all steps in this method are rolledback
      assertEquals(new Integer(0), roleVol);
    }
  }
  @Test
  public void testAddingProductsToCart() throws Exception {

    Customer customer = customerService.createCustomer("A", "Customer");

    Purchase purchase = customerOrderService.createPurchase(customer.getId());

    Product product1 =
        productService.createProduct("Widget1", "a widget that slices (but not dices)", 12.0);
    Product product2 =
        productService.createProduct("Widget2", "a widget that dices (but not slices)", 7.5);

    LineItem one = customerOrderService.addProductToPurchase(purchase.getId(), product1.getId());
    LineItem two = customerOrderService.addProductToPurchase(purchase.getId(), product2.getId());

    purchase = customerOrderService.getPurchaseById(purchase.getId());
    assertTrue(purchase.getTotal() == (product1.getPrice() + product2.getPrice()));

    assertEquals(one.getPurchase().getId(), purchase.getId());
    assertEquals(two.getPurchase().getId(), purchase.getId());

    // this part requires XA to work correctly
    customerOrderService.checkout(purchase.getId());
  }
Exemplo n.º 23
0
 @Test
 public void testGetCustomer() {
   Customer customer = customerService.getCustomer(getMaxCustomerId());
   assertEquals(customer.getFullName().getSurName(), "test");
 }
Exemplo n.º 24
0
  public int addCustomer(JSONObject jObj) {
    int cid = 0;
    String emailId = null;
    Customer customer = new Customer();
    customer.setCreatedAt(Utilities.getCurrentDateTime());
    customer.setUpdatedAt(Utilities.getCurrentDateTime());
    try {
      customer.setCustomerGroupId(jObj.getInt("customerGroup"));
      emailId = jObj.getString("email");
      System.out.println("EMAIL ID:" + emailId);
      customer.setEmail(emailId);
    } catch (JSONException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    if (null == emailId) {
      return cid;
    } else if (isEmailAlreadyExists(emailId)) {
      return cid;
    }
    customerService.addcustomer(customer);
    cid = customer.getId();
    System.out.println("customer==>" + customer.toString());

    List<Entities> listAttributes = this.entitiesService.listAttributes();
    HashMap<Integer, String> attrs = getAttributesList(listAttributes, "Customer");
    System.out.println("attrs==>" + attrs.toString());

    for (Entry<Integer, String> entry : attrs.entrySet()) {
      Integer attrId = entry.getKey();
      String attrName = entry.getValue();

      String attrValue = null;
      try {
        attrValue = jObj.getString(attrName);
      } catch (JSONException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
      if (null != attrValue) {

        CustomerEntityValues custAttrValue = new CustomerEntityValues();
        custAttrValue.setCustomerId(cid);
        custAttrValue.setLanguage("enUS");
        custAttrValue.setAttributeId(attrId);
        custAttrValue.setValue(attrValue);
        customerEntityValuesService.addCustomerAttributeValues(custAttrValue);
        System.out.println("custAttrValue-->" + custAttrValue.toString());
      }
    }

    return cid;

    /* //Rest call
    final String SERVER_URI = "http://localhost:8080/jvoidattributes/listCustomerAttriburtes";
    RestTemplate restTemplate = new RestTemplate();

    String returnString = restTemplate.getForObject(SERVER_URI, String.class);
          JSONObject returnJsonObj = null;
    try {
    	returnJsonObj = new JSONObject(returnString);
    } catch (JSONException e) {
    	// TODO Auto-generated catch block
    	e.printStackTrace();
    }

          System.out.println("returnJsonObj=>"+returnJsonObj);

          JSONArray arr = null;
          try {
    	arr = returnJsonObj.getJSONArray("Attributes");
    } catch (JSONException e) {
    	// TODO Auto-generated catch block
    	e.printStackTrace();
    }

          for (int i=0; i<arr.length(); i++) {
        try {
    		String attrValue = arr.getJSONObject(i).getString("code");
    		Integer attrId = Integer.parseInt(arr.getJSONObject(i).getString("id"));
    		System.out.println("id = "+attrId+"   code = "+attrValue);

    		CustomerAttributeValues custAttrValue = new CustomerAttributeValues();
    	    custAttrValue.setCustomerId(customer.getId());//get it from customer table
    	    custAttrValue.setLanguage("enUS");
    	    custAttrValue.setAttributeId(attrId);
    	    custAttrValue.setValue(customerMaster.toAttributedHashMap().get(attrValue));
    	    customerAttributeValuesService.addCustomerAttributeValues(custAttrValue);
    	    System.out.println("custAttrValue-->"+custAttrValue.toString());
    	} catch (JSONException e) {
    		// TODO Auto-generated catch block
    		e.printStackTrace();
    	}
    }
    */

  }
Exemplo n.º 25
0
 @Test
 public void testUpdateCustomer() {
   Customer customer = customerService.getCustomer(getMaxCustomerId());
   customer.getFullName().setFirstName("test1");
   assert (customerService.updateCustomer(customer));
 }
Exemplo n.º 26
0
 public void displayCustomers() {
   customerService.displayCustomers();
 }
Exemplo n.º 27
0
 public List<Customer> loadCustomers() {
   return customerService.loadCustomers();
 }
Exemplo n.º 28
0
 public void saveCustomers() {
   customerService.saveCustomers();
 }
Exemplo n.º 29
0
 @Test
 public void testDeleteCustomer() {
   assert (customerService.removeCustomer(getMaxCustomerId()));
 }
Exemplo n.º 30
0
 public void addCustomer(Customer c) {
   customerService.addCustomer(c);
 }