#testingmadeeasy

[testrongroup]

Check Out the Concrete Thickness Gauge!

Need to know how thick your concrete is? The TC300 Concrete Thickness Gauge makes it easy! Just point and measure—perfect for construction and building projects. Get accurate results in seconds!

[sophiasoni]

View this post on Instagram

A post shared by Bitts Testing (@bittstesting)

[adafruit]

PCB of the Day! The 2.8" TFT Shield revision finally working nicely 🔧📈✅

Whew, it has been a JOURNEY to revise this 2.8" TFT shield https://www.adafruit.com/product/1651, but we finally see the light at the end of the tunnel. By setting up the TSC2007 through a secondary LDO connected to the power-reset chip, we've eliminated the annoying I2C latch-up. So now we have to design a tester. In this case, we will use a Metro RP2040 https://www.adafruit.com/product/5786, quickly becoming my go-to Metro for test jigs since it has many GPIO, a built-in ROM bootloader, and fast peripherals. Here the chip looks for an SD card plugged into a shield, then displays the image with a touch paint interface for testing all functionality fast! We will order these PCBs tonight and finally put this revision behind us.

[inextures]

Spock-Framework: The Logical Choice for Modern Testing

Introduction

We’ll look at Spock, a Groovy testing framework. Mainly, Spock aims to be a more powerful alternative to the traditional JUnit stack, by leveraging Groovy features.

By making use of Groovy, Spock introduces new and expressive ways of testing our Java applications, which simply aren’t possible in ordinary Java code. We’ll explore some of Spock’s high-level concepts during this article, with some practical step-by-step examples.

Prerequisite

You have some knowledge about spring-boot and testing concept like mocking, Stubbing, etc.

Here we learn the Spock framework with the Spring boot application.

To use Spock in spring boot, add the below dependency into pom.xml

<dependency>   <groupId>org.spockframework</groupId>   <artifactId>spock-core</artifactId>   <version>2.3-groovy-4.0</version>   <scope>test</scope> </dependency> <dependency>   <groupId>org.apache.groovy</groupId>   <artifactId>groovy</artifactId>   <version>4.0.4</version> </dependency>

And add a plugin for groovy support

<plugin>   <groupId>org.codehaus.gmavenplus</groupId>   <artifactId>gmavenplus-plugin</artifactId>   <version>1.5</version>   <executions>       <execution>           <goals>               <goal>compile</goal>               <goal>testCompile</goal>           </goals>       </execution>   </executions> </plugin>

Simple test using Spock framework

Make groovy class and extend the specification to it (spock.lang.specification).

For testing we made one simple method.

@SpringBootTest class Test1 extends Specification {    def "Simple Test"(){        expect:            1+1 == 2  } }

Here “def” keyword is used to define method after this you can add method discerption.

Now run the test

Output:

You see Test Case Passed successfully.

Controller Test-Cases

First, create a ‘Hello’ controller

@RestController public class Hello { @GetMapping("/hello") public String greeting (){    return "Hello World! "; } Now for this controller, we are writing test cases using Spock. class HelloTest extends Specification {   @MockBean   def cont = new Hello ()   MockMvc mvc = MockMvcBuilders.standaloneSetup(cont). build()   def "when get is performed then the response has status 200 and content is 'Hello world!'"() {       expect: "Status is 200 and the response is 'Hello world!'"       mvc.perform(MockMvcRequestBuilders.get("/hello"))               .andExpect(status().isOk())               .andReturn()               .response               .contentAsString == "Hello World! "   } } Output:

Keywords:

Expect: This is a way of performing our stimulus and assertion within the same block. Depending on what we find more expressive, we may or may not choose to use this block

When – This is where we provide a stimulus to what is under test. In other words, where we invoke our method under test

Then – This is where the assertions belong. In Spock, these are evaluated as plain Boolean assertions, which will be covered later

Important Tips

1) All the blocks in a Spock based spec are optional. However, if present “when” and “then” should appear together in sequence.

2) If you just need to validate an assertion (and you don’t have a need of when block), you can use “expect” block. It can be used to assert pre-conditions even before when and then blocks (and can be used multiple times in a test).

Important Functions

Here We Have 4 Methods used to define global or redundant code.

/** * Call only one time for all test cases * You can define a spec for static or whole test cases that have the same value * */ def setupSpec() { } /** * Call only once at the end of all test cases * */ def cleanupSpec() { } /** * Call for every test case * It calls for every time before the test case * */ def setup () { } /** * Call for every test case * It calls for every time after test case * */ def cleanup() { }

Originally published by: Spock-Framework