TestData Builder(( - Entwicklertag · private static Order createOrderWithValueOf(double value) {...

Test-‐Data Builder

ma0hias.bisping mar7n.klose @klosebrothers.de

h#p://flickr.com/photos/editor/6698208975

komplexes Test-‐Setup

Abhängigkeiten

komplexe Objekte

Duplika7on

Fragile Tests

h#p://flickr.com/photos/jonodavis/7476648174/

Legacy Code testen

Test / Refaktor Dilemma

h#p://flickr.com/photos/the-‐wanderers-‐eye/4494147652/

Noise

101 Test-‐Data Builder

Kunden Scoring

h#p://flickr.com/photos/anythreewords/336903507/

Score •  Umsätze der letzten 12 Monate

•  je 1.000 EUR Umsatz 1 Punkt

•  Zahlungsverzug 5 Punkte Abzug

Score bis 4 => Vorkasse 4 bis 8 => Vorkasse Nachnahme

über 8 => Vorkasse Nachnahme Rechnung

Arrange Act

Assert William C. Wake

Arrange Objects

h#p://flickr.com/photos/50896278@N06/6134612964/

@Test public void a_customer_with_a_score_of_4_can_pay_in_advance_and_on_delivery() {

Address aAddress = new Address("Meisenstrasse 96", "33607", "Bielefeld");Customer aCustomer = new Customer("Mustermann AG", aAddress);

Order order = new Order();order.setValue(4000);order.setPayed(true);order.setOrderDate(new Date());

aCustomer.addOrder(order);

assertThat(aCustomer.getPossiblePaymentMethods(), containsInAnyOrder( PaymentMethod.prepayment, PaymentMethod.cashOnDelivery ));

}






}






}






}






}






}






}

Factory-‐Methoden






}






}





} private Customer aCustomer; @Before public void init() { Address aAddress = new Address("Meisenstrasse 96", "33607", "Bielefeld"); aCustomer = new Customer("Mustermann AG", aAddress); }





}





}


aCustomer.addOrder(createOrderWithValueOf(4000));assertThat(aCustomer.getPossiblePaymentMethods(), containsInAnyOrder( PaymentMethod.prepayment, PaymentMethod.cashOnDelivery ));

}



} private static Order createOrderWithValueOf(double value) {

Order order = new Order();order.setValue(value);order.setPayed(true);order.setOrderDate(new Date());return order;

}

private static Order createOrderWithValueOf(double value) { return createOrder(value, true, thisYear());}private static Order createOrderFromThisYearWithValue(double value) {

return createOrder(value, true, thisYear());}private static Order createOrderFromLastYearWithValue(double value) {

return createOrder(value, true, lastYear());}private static Order createOrderWithPaymentDeficitAndValueOf(double value) { return createOrder(value, false, thisYear());}private static Order createOrderWithPaymentDeficitFromLastYearWithValueOf

(double value) {return createOrder(1000, false, lastYear());

}





}





}





}





}

„Separate the construc,on of a complex object from its representa,on so that the same construc5on process can create different representa5ons.“

einfacher Test-‐Data Builder



}



}


aCustomer = new CustomerBuilder() .withScore(4) .build();


}




}




}




}




}

Customer Builder




}




}

public class CustomerBuilder { private Customer innerCustomer; public CustomerBuilder() { Address aAddress = new Address("Meisenstrasse 96", "33607", "BI"); innerCustomer = new Customer("Mustermann AG", aAddress); }

public CustomerBuilder withName(String name){

innerCustomer.setName(name); return this; } public CustomerBuilder withScore(int score) { Order order = new Order(); order.setValue(score*1000); order.setPayed(true); order.setOrderDate(new Date()); innerCustomer.addOrder(order); return this; } public Customer build() { return innerCustomer; } }


































kombinierte Test-‐Data Builder

@Test public void the_score_should_be_one_with_a_single_1k_order() { aCustomer = new CustomerBuilder() .with( new OrderBuilder() .withValue(1000)) .build();

assertThat(aCustomer.getScore(), is(1));}


assertThat(aCustomer.getScore(), is(1));}


assertThat(aCustomer.getScore(), is(1)); }


assertThat(aCustomer.getScore(), is(1)); }public class CustomerBuilder { private Customer innerCustomer;

...public CustomerBuilder with(OrderBuilder order) {

innerCustomer.addOrder( order.build()

); return this; }}





); return this; }}





); return this; }}





); return this; }}





); return this; }}





); return this; }}

OrderBuilder by the book

public class OrderBuilder {private double value = 1000;private Date orderDate = thisYear();private boolean payed = true;

public OrderBuilder() { } public OrderBuilder withValue(double value) { this.value = value; return this; } public OrderBuilder withPaymentDefictit() { payed = false; return this; } public Order build() { Order order= new Order();

order.setOrderDate(orderDate); order.setPayed(payed); order.setValue(value); return order; }













OrderBuilder mit innerOrder

public class OrderBuilder { private Order innerOrder; public OrderBuilder() { innerOrder = new Order(); innerOrder.setOrderDate(thisYear()); innerOrder.setPayed(true); innerOrder.setValue(1000); } public OrderBuilder withValue(double value) { innerOrder.setValue(value); return this; } public OrderBuilder withPaymentDefictit() { innerOrder.setPayed(false); return this; } public Order build() { return innerOrder; }}





Test-‐Data Builder

mit Factories

@Test public void the_score_should_be_two_with_two_1k_orders() { aCustomer = new CustomerBuilder() .with( anOrder() .withValue(1000) ) .with( anOrder() .withValue(1000) ) .build(); assertThat(aCustomer.getScore(), is(2)); }

@Test public void the_score_should_be_two_with_two_1k_orders() { aCustomer = new CustomerBuilder() .with( anOrder() .withValue(1000) ) .with( anOrder() .withValue(1000) ) .build(); assertThat(aCustomer.getScore(), is(2)); }

@Test public void the_score_should_be_two_with_two_1k_orders() { aCustomer = aCustomer() .with( anOrder() .withValue(1000) ) .with( anOrder() .withValue(1000) ) .build(); assertThat(aCustomer.getScore(), is(2)); }

@Test public void the_score_should_be_two_with_two_1k_orders() { aCustomer = aCustomer() .with( anOrder() .withValue(1000) ) .with( anOrder() .withValue(1000) ) .build(); assertThat(aCustomer.getScore(), is(2)); } public static CustomerBuilder aCustomer() { return new CustomerBuilder(); }

@Test public void the_score_should_be_two_with_two_1k_orders() { aCustomer = aCustomer() .with( anOrder() .withValue(1000) ) .with( anOrder() .withValue(1000) ) .build(); assertThat(aCustomer.getScore(), is(2)); } public static CustomerBuilder aCustomer() { return new CustomerBuilder(); }

@Test public void the_score_should_be_two_with_two_1k_orders() { aCustomer = aCustomer() .with( anOrder() .withValue(1000) ) .with( anOrder() .withValue(1000) ) .build(); assertThat(aCustomer.getScore(), is(2)); } public static CustomerBuilder aCustomer() { return new CustomerBuilder(); } public static OrderBuilder anOrder() { return new OrderBuilder(); }




Reduce noise

private Customer aCustomer; @Test public void the_score_should_be_one_with_a_single_1k_order() { aCustomer = aCustomer() .with( anOrder() .withValue(1000)

) .build(); assertThat(aCustomer.getScore(), is(1));

}



}



}

private CustomerBuilder aCustomer; @Test public void the_score_should_be_one_with_a_single_1k_order() { aCustomer = aCustomer() .with( anOrder() .withValue(1000)


}



}


); assertThat(aCustomer.getScore(), is(1));}


); assertThat(aCustomer.build().getScore(), is(1));}


); assertThat(aCustomer.build().getScore(), is(1)); assertThat(aCustomer.getScore(), is(1));}



public class CustomerBuilder {

...public int getScore() { return build().getScore();}

}





}





}




); assertThat(aCustomer.build().getScore(), is(1)); assertThat(aCustomer.getScore(), is(1)); assertThat(score(aCustomer), is(1));}



private int score(CustomerBuilder customer){

return customer.build().getScore(); }




); assertThat(aCustomer.build().getScore(), is(1)); assertThat(aCustomer.getScore(), is(1)); assertThat(score(aCustomer), is(1)); assertScore(aCustomer, is(1));}



private void assertScore(CustomerBuilder customer, Matcher<Integer> matcher) {

assertThat(customer.build().getScore(), matcher);

}




); assertThat(aCustomer.build().getScore(), is(1)); assertThat(aCustomer.getScore(), is(1)); assertThat(score(aCustomer), is(1)); assertThatScoreOf(aCustomer, is(1));}


); assertThat(aCustomer.build().getScore(), is(1)); assertThat(aCustomer.getScore(), is(1)); assertThat(score(aCustomer), is(1)); assertThatScoreOf(aCustomer, is(1));}


); assertThat(aCustomer.build().getScore(), is(1)); assertThat(aCustomer.getScore(), is(1)); assertThat(scoreFor(aCustomer), is(1)); assertThatScoreOf(aCustomer, is(1));}


); assertThat(aCustomer.build().getScore(), is(1)); assertThat(aCustomer.getScore(), is(1)); assertThat(scoreFor(aCustomer), is(1)); assertThatScoreOf(aCustomer, is(1));}

Copy / but

@Testpublic void two_orders_are_not_equal_when_value_is_not_equal() { OrderBuilder anOrder = new OrderBuilder() .withValue(1000) .withOrderDate("01.01.2014") .withIsPayed(true); OrderBuilder anotherOrder = anOrder .but().withValue(2000); assertThat(anOrder.build(), not(equalTo(anotherOrder.build())));}




public class OrderBuilder {

...public OrderBuilder but() {

return new OrderBuilder() .withValue(innerOrder.getValue()) .withIsPayed(innerOrder.isPayed()) .withOrderDate(innerOrder.getOrderDate()); }}


@Testpublic void two_orders_are_not_equal_when_value_is_not_equal() { OrderBuilder anOrder = new OrderBuilder() .withValue(1000) .withOrderDate("01.01.2014") .withIsPayed(true); OrderBuilder anotherOrder = new OrderBuilder(anOrder) .withValue(2000); assertThat(anOrder.build(), not(equalTo(anotherOrder.build())));}

h#p://flickr.com/photos/lucynieto/2854010435

Fazit

(Test) Setup vereinfacht







Entkopplung

h#p://flickr.com/photos/Ym_ellis/2622333378

(Legacy) Code testbar machen

Workshops Coaching / Beratung SoTwareentwicklung

@mar7nklose [email protected]

Kontakt

Date post:	10-Oct-2020
Category:	Documents
Upload:	others
View:	1 times
Download:	0 times

TestData Builder(( - Entwicklertag · private static Order createOrderWithValueOf(double value) {...

Documents