@Test
public void updateCreditCardFromTransparentRedirect() {
Customer customer = gateway.customer().create(new CustomerRequest()).getTarget();
CreditCardRequest request =
new CreditCardRequest()
.customerId(customer.getId())
.number("5105105105105100")
.expirationDate("05/12");
CreditCard card = gateway.creditCard().create(request).getTarget();
CreditCardRequest updateRequest = new CreditCardRequest();
CreditCardRequest trParams =
new CreditCardRequest()
.paymentMethodToken(card.getToken())
.number("4111111111111111")
.expirationDate("10/10");
String queryString =
TestHelper.simulateFormPostForTR(
gateway, trParams, updateRequest, gateway.transparentRedirect().url());
Result<CreditCard> result = gateway.transparentRedirect().confirmCreditCard(queryString);
assertTrue(result.isSuccess());
CreditCard updatedCreditCard = gateway.creditCard().find(card.getToken());
assertEquals("411111", updatedCreditCard.getBin());
assertEquals("1111", updatedCreditCard.getLast4());
assertEquals("10/2010", updatedCreditCard.getExpirationDate());
}
@Test
public void onCustomer() {
Result<Customer> customerResult =
gateway.customer().create(new CustomerRequest().paymentMethodNonce(Nonce.Coinbase));
assertTrue(customerResult.isSuccess());
Customer customer = customerResult.getTarget();
List<CoinbaseAccount> accounts =
gateway.customer().find(customer.getId()).getCoinbaseAccounts();
assertEquals(1, accounts.size());
CoinbaseAccount account = accounts.get(0);
assertNotNull(account);
assertNotNull(account.getToken());
assertNotNull(account.getUserId());
assertThat(account.getUserId(), not(equalTo("")));
assertNotNull(account.getUserName());
assertThat(account.getUserName(), not(equalTo("")));
assertNotNull(account.getUserEmail());
assertThat(account.getUserEmail(), not(equalTo("")));
String token = account.getToken();
gateway.paymentMethod().delete(token);
exception.expect(NotFoundException.class);
gateway.paymentMethod().find(token);
}
private Customer getNewCustomerWithUniqueName() {
Customer c1 = getCustomerComponent().createNew();
c1.setName("A" + System.currentTimeMillis());
c1.setPhoneNumber("808-555-1212");
getCustomerComponent().persist(c1);
return c1;
}
@Theory
public void test(Fixture fixture1, Fixture fixture2) {
// 【テスト条件のセットアップ】
if (fixture1 != null) {
sut.addRental(fixture1.rental);
}
if (fixture2 != null) {
sut.addRental(fixture2.rental);
}
// 【テスト実施】
String result = sut.statement();
// 【テスト結果の検証】
// 期待値作成
String expected = "Rental Record for " + CUSTOMER_NAME + "\n";
expected += buildAmountPartString(fixture1);
expected += buildAmountPartString(fixture2);
double totalAmount = calcTotalAmount(fixture1, fixture2);
expected += "Amount owed is " + String.valueOf(totalAmount) + "\n";
int frequentREnterPoints = calcPoint(fixture1, fixture2);
expected += "You earned " + String.valueOf(frequentREnterPoints) + " frequent renter points";
assertThat(result, is(expected));
}
@Test
public void getAllCustomerCars() {
assertFalse(customer1.getActive());
assertFalse(customer2.getActive());
assertFalse(customer3.getActive());
manager.rentCarToCustomer(
car2, customer1, Date.valueOf("2012-03-21"), Date.valueOf("2012-03-31"));
manager.rentCarToCustomer(
car3, customer1, Date.valueOf("2012-03-25"), Date.valueOf("2012-04-02"));
manager.rentCarToCustomer(
car1, customer2, Date.valueOf("2012-03-15"), Date.valueOf("2012-03-27"));
List<Car> carsRetnedtoCustomer1 = Arrays.asList(car2, car3);
List<Car> carsRetnedtoCustomer2 = Arrays.asList(car1);
assertCarDeepEquals(carsRetnedtoCustomer1, manager.getAllCustomerCars(customer1));
assertCarDeepEquals(carsRetnedtoCustomer2, manager.getAllCustomerCars(customer2));
assertFalse(customer3.getActive());
try {
manager.getAllCustomerCars(null);
fail();
} catch (IllegalArgumentException e) {
}
try {
manager.getAllCustomerCars(customerWithoutID);
fail();
} catch (IllegalArgumentException e) {
}
}
/**
* Test case to show the usage of the geo-spatial APIs to lookup people within a given distance of
* a reference point.
*/
@Test
public void exposesGeoSpatialFunctionality() {
GeospatialIndex indexDefinition = new GeospatialIndex("address.location");
indexDefinition.getIndexOptions().put("min", -180);
indexDefinition.getIndexOptions().put("max", 180);
operations.indexOps(Customer.class).ensureIndex(indexDefinition);
Customer ollie = new Customer("Oliver", "Gierke");
ollie.setAddress(new Address(new Point(52.52548, 13.41477)));
ollie = repository.save(ollie);
Point referenceLocation = new Point(52.51790, 13.41239);
Distance oneKilometer = new Distance(1, Metrics.KILOMETERS);
GeoResults<Customer> result =
repository.findByAddressLocationNear(referenceLocation, oneKilometer);
assertThat(result.getContent(), hasSize(1));
Distance distanceToFirstStore = result.getContent().get(0).getDistance();
assertThat(distanceToFirstStore.getMetric(), is(Metrics.KILOMETERS));
assertThat(distanceToFirstStore.getValue(), closeTo(0.862, 0.001));
}
private void prepareTestData() {
car1 = newCar("Black", "0B6 6835", "Škoda", 200.0);
car2 = newCar("Red", "7B4 0044", "BMW", 500.0);
car3 = newCar("White", "8B5 0983", "Volkwagen", 300.0);
customer1 = newCustomer("Vitalii", "Chepeliuk", "Komarov", "5-20-86", "AK 373979");
customer2 = newCustomer("Juraj", "Kolchak", "Komarov", "5-34-86", "AK 372548");
customer3 = newCustomer("Martin", "Jirman", "Lazhot", "5-25-87", "AK 251245");
carManager.addCar(car1);
carManager.addCar(car2);
carManager.addCar(car3);
customerManager.addCustomer(customer1);
customerManager.addCustomer(customer2);
customerManager.addCustomer(customer3);
carWithoutID = newCar("Green", "8B3 9763", "Audi", 400.0);
carNotInDB = newCar("Blue", "3B6 8463", "Peugeot", 0.0);
carNotInDB.setID(car3.getID() + 100);
customerWithoutID = newCustomer("Martin", "Pulec", "Brno", "5-11-24", "AK 897589");
customerNotInDB = newCustomer("Lukas", "Rucka", "Brno", "5-21-06", "AK 256354");
customerNotInDB.setID(customer3.getID() + 100);
customerNotInDB.setActive(true);
}
@Test
public void testDoAdapterWithRewardCustomer() throws Exception {
Customer customer = getCustomerByFile(super.FILE_CUSTOMER_REWARDS);
assertNotNull(customer);
assertNotNull(customer.getType());
assertEquals(CustomerTypeEnum.REWARDS, customer.getType());
}
@Test
public void testDeleteCustomer() {
Customer c1 = getNewCustomerWithUniqueName();
Customer c1FromDb = getCustomerComponent().getById(c1.getId());
getCustomerComponent().delete(c1FromDb);
Customer c1FromDbAgain = getCustomerComponent().getById(c1.getId());
assertNull(c1FromDbAgain);
}
public void orderTest3() {
Customer customer = customerDAO.getCustomerById(2);
List list = orderService.getOrdersByUsername(customer.getUsername());
System.out.println("List size :" + list.size());
for (Object obj : list) {
System.out.println(obj);
}
}
@Test
public void testAutowireCandidateTrue() {
Customer customer = applicationContext.getBean("customer", Customer.class);
assertNotNull(customer);
assertNotNull(customer.getOrder());
assertNull(customer.getOrder().getItem());
assertNotNull(customer.getCart());
}
@Test
public void testWithOneChildrensMovie_ShouldGenerateSimpleStatement() {
Movie irongiant = new Movie("Iron Giant", Movie.CHILDRENS);
Rental sunday = new Rental(irongiant, 2);
customer.addRental(sunday);
assertEquals(
"Rental Record for Ryan\n"
+ "\tIron Giant\t1.5\n"
+ "Amount owed is 1.5\n"
+ "You earned 1 frequent renters points",
customer.statement());
}
@Test
public void testWithOneNewReleaseMovie_ShouldGenerateSimpleStatement() {
Movie ironman = new Movie("Iron Man 2", Movie.NEW_RELEASE);
Rental sunday = new Rental(ironman, 2);
customer.addRental(sunday);
assertEquals(
"Rental Record for Ryan\n"
+ "\tIron Man 2\t6.0\n"
+ "Amount owed is 6.0\n"
+ "You earned 2 frequent renters points",
customer.statement());
}
@Test
public void testWithOneRegularMovie_ShouldGenerateSimpleStatement() {
Movie ironman = new Movie("Iron Man", Movie.REGULAR);
Rental sunday = new Rental(ironman, 2);
customer.addRental(sunday);
assertEquals(
"Rental Record for Ryan\n"
+ "\tIron Man\t2.0\n"
+ "Amount owed is 2.0\n"
+ "You earned 1 frequent renters points",
customer.statement());
}
/** This method tests the requirement that the address can not null */
@Test(expected = IllegalArgumentException.class)
public void addressShouldNotBeNull() {
// Customer customer = new Customer();
instance.setAddress(null);
// assertNotNull(instance.getAddress());
}
@Test
public void testCustomerList() throws HTTPError {
ArrayList<Customer> customers = Customer.query().all();
// Customer.Collection customers = mp.customers;
// assertTrue(customers.getClass().equals(Customer.Collection.class));
assertTrue(customers.size() > 0);
}
@Test
public void testWithNoMovie_ShouldGenerateEmptyStatement() {
assertEquals(
"Rental Record for Ryan\n"
+ "Amount owed is 0.0\n"
+ "You earned 0 frequent renters points",
customer.statement());
}
@Test
public void testDoAdapterWithAllMonths() throws Exception {
Customer customer = getCustomerByFile(super.FILE_INPUT_MONTHS);
assertEquals(MonthEnum.values().length, customer.getReservations().size());
// The order of MonthEnum must bem the same that of the file.
Iterator<DateReservation> iterator = customer.getReservations().iterator();
for (MonthEnum month : MonthEnum.values()) {
if (iterator.hasNext()) {
MonthEnum monthEnum = iterator.next().getMoth();
assertEquals(month, monthEnum);
} else {
fail();
}
}
}
@Test
public void testWithOneOfEachTypeOfMovieFor3Days_ShouldGenerateComplexStatement() {
Movie ironman = new Movie("Iron Man", Movie.REGULAR);
customer.addRental(new Rental(ironman, 3));
Movie irongiant = new Movie("Iron Giant", Movie.CHILDRENS);
customer.addRental(new Rental(irongiant, 3));
Movie ironman2 = new Movie("Iron Man 2", Movie.NEW_RELEASE);
customer.addRental(new Rental(ironman2, 3));
assertEquals(
"Rental Record for Ryan\n"
+ "\tIron Man\t3.5\n"
+ "\tIron Giant\t1.5\n"
+ "\tIron Man 2\t9.0\n"
+ "Amount owed is 14.0\n"
+ "You earned 4 frequent renters points",
customer.statement());
}
@Test
public void testCustomerInsertAndGet() {
Customer c1 = getNewCustomerWithUniqueName();
Customer c2 = getNewCustomerWithUniqueName();
assertEquals(c1.getId() + 1, c2.getId());
Customer c1FromDb = getCustomerComponent().getById(c1.getId());
assertEquals(c1.getName(), c1FromDb.getName());
}
/** Tests the functionality of the get methods for the customer class */
@Test
public void CustomerGetMethods() {
assertEquals(1, testCustomer.getCustomerID());
assertEquals("01782566491", testCustomer.getCustomerPhone());
assertEquals(10000f, testCustomer.getAvailableCredit(), 0.001f);
assertEquals("George Freshwater", testCustomer.getCustomerName());
assertEquals("*****@*****.**", testCustomer.getCustomerEmail());
assertEquals("fresh", testCustomer.getCustomerUsername());
assertEquals("water123", testCustomer.getCustomerPassword());
assertEquals("EMAIL", testCustomer.getCustomerContactMethod());
}
/** City name should not be empty */
@Test
public void validCityNameShouldPass() {
String[] validCity = {"a", "xxx", "xxxxxx"};
try {
for (String vc : validCity) {
instance.setCity(vc);
}
} catch (Exception e) {
fail("Legal value was rejected, not good!");
}
}
@Test
public void testCustomerUpdateAndGet() {
Customer c1 = getNewCustomerWithUniqueName();
Customer c1FromDb = getCustomerComponent().getById(c1.getId());
String NEW_PHONE = "415-555-1212";
c1FromDb.setPhoneNumber(NEW_PHONE);
getCustomerComponent().persist(c1FromDb);
Customer c1FromDbAgain = getCustomerComponent().getById(c1.getId());
assertEquals(NEW_PHONE, c1FromDbAgain.getPhoneNumber());
}
@Test
public void testMerchantStatusNoMatch() throws HTTPError {
Map<String, Object> payload = new HashMap<String, Object>();
payload.put("name", "John Lee Hooker");
payload.put("phone", "(904) 555-1796");
Map<String, String> address = new HashMap<String, String>();
address.put("city", "San Francisco");
address.put("state", "CA");
address.put("postal_code", "94103");
address.put("line1", "965 Mission St");
address.put("country_code", "US");
payload.put("address", address);
payload.put("ssn_last4", "3209");
Customer merchant = new Customer(payload);
merchant.save();
assertEquals("no-match", merchant.merchant_status);
}
@Test
public void testDoAdapterWithAllWeekDays() throws Exception {
Customer customer = getCustomerByFile(super.FILE_INPUT_WEEK_DAYS);
// The order of WeekDayEnum must bem the same that of the file.
Iterator<DateReservation> iterator = customer.getReservations().iterator();
for (WeekDayEnum weekDay : WeekDayEnum.values()) {
// ignore days not present on file
if (weekDay.equals(WeekDayEnum.WEEKDAY) || weekDay.equals(WeekDayEnum.WEEKEND)) {
continue;
}
if (iterator.hasNext()) {
WeekDayEnum weekDay1 = iterator.next().getWeekDay();
assertEquals(weekDay, weekDay1);
} else {
fail();
}
}
}
public void paymentTest() {
Payment payment = new Payment();
// 取出订单
Order order = orderDAO.getOrderById(8);
// 取出订单顾客
Customer customer = order.getCustomer();
// 取出操作员
Worker worker = workerDAO.getWorkerById(7);
// 取出银行卡
Bankcard bankcard = customer.getBankcardList().get(0);
payment.setPayCustomer(customer);
System.out.println("OrderId:" + order.getOrderId());
payment.setPayOrder(order);
System.out.println(bankcard);
payment.setPayCard(bankcard);
payment.setPayPrice(order.getOrderPrice());
payment.setPayType(1);
payment.setWorker(worker);
paymentDAO.createPayment(payment);
}
public static String generateEuropeBankAccountNonce(BraintreeGateway gateway, Customer customer) {
SEPAClientTokenRequest request = new SEPAClientTokenRequest();
request.customerId(customer.getId());
request.mandateType(EuropeBankAccount.MandateType.BUSINESS);
request.mandateAcceptanceLocation("Rostock, Germany");
String encodedClientToken = gateway.clientToken().generate(request);
String clientToken = TestHelper.decodeClientToken(encodedClientToken);
String authorizationFingerprint = extractParamFromJson("authorizationFingerprint", clientToken);
Configuration configuration = gateway.getConfiguration();
String url =
configuration.getBaseURL()
+ configuration.getMerchantPath()
+ "/client_api/v1/sepa_mandates";
QueryString payload = new QueryString();
payload
.append("authorization_fingerprint", authorizationFingerprint)
.append("sepa_mandate[locale]", "de-DE")
.append("sepa_mandate[bic]", "DEUTDEFF")
.append("sepa_mandate[iban]", "DE89370400440532013000")
.append("sepa_mandate[accountHolderName]", "Bob Holder")
.append("sepa_mandate[billingAddress][streetAddress]", "123 Currywurst Way")
.append("sepa_mandate[billingAddress][extendedAddress]", "Lager Suite")
.append("sepa_mandate[billingAddress][firstName]", "Wilhelm")
.append("sepa_mandate[billingAddress][lastName]", "Dix")
.append("sepa_mandate[billingAddress][locality]", "Frankfurt")
.append("sepa_mandate[billingAddress][postalCode]", "60001")
.append("sepa_mandate[billingAddress][countryCodeAlpha2]", "DE")
.append("sepa_mandate[billingAddress][region]", "Hesse");
String responseBody;
String nonce = "";
try {
responseBody = HttpHelper.post(url, payload.toString());
nonce = extractParamFromJson("nonce", responseBody);
} catch (Exception e) {
throw new RuntimeException(e);
}
return nonce;
}
@Test
public void updateCustomerFromTransparentRedirect() {
CustomerRequest request = new CustomerRequest().firstName("John").lastName("Doe");
Customer customer = gateway.customer().create(request).getTarget();
CustomerRequest updateRequest = new CustomerRequest().firstName("Jane");
CustomerRequest trParams = new CustomerRequest().customerId(customer.getId()).lastName("Dough");
String queryString =
TestHelper.simulateFormPostForTR(
gateway, trParams, updateRequest, gateway.transparentRedirect().url());
Result<Customer> result = gateway.transparentRedirect().confirmCustomer(queryString);
assertTrue(result.isSuccess());
Customer updatedCustomer = gateway.customer().find(customer.getId());
assertEquals("Jane", updatedCustomer.getFirstName());
assertEquals("Dough", updatedCustomer.getLastName());
}
@Test
public void getCarFromCustomer() {
assertTrue(car1.getAvailable());
assertTrue(car2.getAvailable());
assertTrue(car3.getAvailable());
manager.rentCarToCustomer(
car1, customer1, Date.valueOf("2012-03-21"), Date.valueOf("2012-03-31"));
manager.rentCarToCustomer(
car2, customer1, Date.valueOf("2012-03-25"), Date.valueOf("2012-04-02"));
manager.rentCarToCustomer(
car3, customer2, Date.valueOf("2012-03-15"), Date.valueOf("2012-03-27"));
assertEquals(customer1, manager.findCustomerWithCar(car1));
assertCustomerDeepEquals(customer1, manager.findCustomerWithCar(car1));
assertEquals(customer1, manager.findCustomerWithCar(car2));
assertCustomerDeepEquals(customer1, manager.findCustomerWithCar(car2));
assertEquals(customer2, manager.findCustomerWithCar(car3));
assertCustomerDeepEquals(customer2, manager.findCustomerWithCar(car3));
manager.getCarFromCustomer(car3, customer2);
List<Car> carsRetnedtoCustomer1 = Arrays.asList(car1, car2);
assertCarDeepEquals(carsRetnedtoCustomer1, manager.getAllCustomerCars(customer1));
assertFalse(customer2.getActive());
assertFalse(customer3.getActive());
assertEquals(customer1, manager.findCustomerWithCar(car1));
assertCustomerDeepEquals(customer1, manager.findCustomerWithCar(car1));
assertEquals(customer1, manager.findCustomerWithCar(car2));
assertCustomerDeepEquals(customer1, manager.findCustomerWithCar(car2));
assertTrue(car3.getAvailable());
try {
manager.getCarFromCustomer(car3, customer1);
fail();
} catch (TransactionException e) {
}
try {
manager.getCarFromCustomer(car3, customer2);
fail();
} catch (IllegalArgumentException e) {
}
try {
manager.getCarFromCustomer(null, customer1);
fail();
} catch (IllegalArgumentException e) {
}
try {
manager.getCarFromCustomer(carWithoutID, customer1);
fail();
} catch (IllegalArgumentException e) {
}
try {
manager.getCarFromCustomer(carNotInDB, customer1);
fail();
} catch (TransactionException e) {
}
try {
manager.getCarFromCustomer(car1, null);
fail();
} catch (IllegalArgumentException e) {
}
try {
manager.getCarFromCustomer(car1, customerWithoutID);
fail();
} catch (IllegalArgumentException e) {
}
try {
manager.getCarFromCustomer(car1, customerNotInDB);
fail();
} catch (TransactionException e) {
}
// Check that previous tests didn't affect data in database
assertCarDeepEquals(carsRetnedtoCustomer1, manager.getAllCustomerCars(customer1));
assertFalse(customer2.getActive());
assertFalse(customer3.getActive());
assertEquals(customer1, manager.findCustomerWithCar(car1));
assertCustomerDeepEquals(customer1, manager.findCustomerWithCar(car1));
assertEquals(customer1, manager.findCustomerWithCar(car2));
assertCustomerDeepEquals(customer1, manager.findCustomerWithCar(car2));
assertTrue(car3.getAvailable());
}
@Test
public void validZipCodeShouldPass() {
instance.setZip("12345");
}
