Add new JPA smoke test to validate the IAST visitor

dd-smoke-tests/springboot-jpa/build.gradle

@@ -0,0 +1,30 @@
+plugins {
+  id 'java'
+  id 'war'
+  id 'org.springframework.boot' version '2.6.0'
+}
+
+apply plugin: 'io.spring.dependency-management'
+apply from: "$rootDir/gradle/java.gradle"
+description = 'SpringBoot JPA Smoke Tests.'
+
+dependencies {
+  implementation 'org.springframework.boot:spring-boot-starter-web'
+  implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+  implementation 'org.apache.tomcat.embed:tomcat-embed-jasper'
+  implementation 'javax.servlet:jstl:1.2'
+  implementation 'com.h2database:h2:2.1.214'
+
+  testImplementation project(':dd-smoke-tests')
+
+  compileOnly 'org.projectlombok:lombok:1.18.34'
+  annotationProcessor 'org.projectlombok:lombok:1.18.34'
+
+  testCompileOnly 'org.projectlombok:lombok:1.18.34'
+  testAnnotationProcessor 'org.projectlombok:lombok:1.18.34'
+}
+
+tasks.withType(Test).configureEach {
+  dependsOn "bootWar"
+  jvmArgs "-Ddatadog.smoketest.springboot.bootWar.path=${tasks.bootWar.archiveFile.get()}"
+}

dd-smoke-tests/springboot-jpa/src/main/java/datadog/smoketest/springboot/SpringbootApplication.java

@@ -0,0 +1,20 @@
+package datadog.smoketest.springboot;
+
+import datadog.smoketest.springboot.filter.SessionVisitorFilter;
+import javax.servlet.Filter;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+
+@SpringBootApplication
+public class SpringbootApplication {
+
+  @Bean
+  public Filter badBehaviorFilter() {
+    return new SessionVisitorFilter();
+  }
+
+  public static void main(final String[] args) {
+    SpringApplication.run(SpringbootApplication.class, args);
+  }
+}

dd-smoke-tests/springboot-jpa/src/main/java/datadog/smoketest/springboot/controller/LibraryController.java

@@ -0,0 +1,114 @@
+package datadog.smoketest.springboot.controller;
+
+import static java.util.Arrays.asList;
+
+import datadog.smoketest.springboot.entity.Author;
+import datadog.smoketest.springboot.entity.Book;
+import datadog.smoketest.springboot.entity.Library;
+import datadog.smoketest.springboot.entity.Owner;
+import datadog.smoketest.springboot.service.LibraryService;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+import lombok.RequiredArgsConstructor;
+import org.hibernate.collection.internal.PersistentBag;
+import org.hibernate.proxy.HibernateProxy;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.ModelMap;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.ModelAttribute;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.SessionAttributes;
+import org.springframework.web.bind.support.SessionStatus;
+
+@Controller
+@RequestMapping("/library")
+@SessionAttributes(LibraryController.COMMAND_NAME)
+@RequiredArgsConstructor
+public class LibraryController {
+
+  public static final String COMMAND_NAME = "library";
+
+  private final LibraryService libraryService;
+
+  @GetMapping("/{id}")
+  public ResponseEntity<Boolean> hasIssue(@PathVariable final int id) {
+    return ResponseEntity.ok(libraryService.findLibraryById(id).isIssueExists());
+  }
+
+  @GetMapping
+  public ResponseEntity<Integer> create() {
+    final Library library =
+        Library.builder()
+            .books(
+                asList(
+                    Book.builder()
+                        .title("The Lord of the Rings")
+                        .owner(Owner.builder().name("Peter Jackson").build())
+                        .authors(
+                            asList(
+                                Author.builder().name("J.R.R Tolkien").build(),
+                                Author.builder().name("Peter Jackson").build()))
+                        .build(),
+                    Book.builder()
+                        .title("The Hobbit")
+                        .owner(Owner.builder().name("Edith Tolkien").build())
+                        .authors(
+                            asList(
+                                Author.builder().name("J.R.R Tolkien").build(),
+                                Author.builder().name("Edith Tolkien").build()))
+                        .build()))
+            .build();
+    libraryService.save(library);
+    return ResponseEntity.ok(library.getId());
+  }
+
+  @GetMapping("/update/{id}")
+  public String update(@PathVariable final int id, final ModelMap model) {
+    final Library library = libraryService.findLibraryById(id);
+    model.put(COMMAND_NAME, library);
+    return "update";
+  }
+
+  @GetMapping("/update")
+  public String update(
+      @ModelAttribute(COMMAND_NAME) final Library library, final SessionStatus sessionStatus) {
+    libraryService.update(library);
+    sessionStatus.setComplete();
+    return "redirect:/library/" + library.getId();
+  }
+
+  @GetMapping("/session/add/{id}")
+  public ResponseEntity<String> addToSession(
+      @RequestParam("mode") final String mode,
+      @PathVariable final int id,
+      final HttpServletRequest request) {
+    final Library library = libraryService.findLibraryById(id);
+    final Book book = library.getBooks().get(0);
+    final HttpSession session = request.getSession();
+    if (mode.equals("one-to-one")) {
+      session.setAttribute(mode, book.getOwner());
+    } else {
+      session.setAttribute(mode, book.getAuthors());
+    }
+    return ResponseEntity.ok("OK");
+  }
+
+  @GetMapping("/session/validate")
+  public ResponseEntity<Boolean> validateSession(
+      @RequestParam("mode") final String mode, final HttpServletRequest request) {
+    final HttpSession session = request.getSession();
+    final Object sessionItem = session.getAttribute(mode);
+    final boolean loaded;
+    if (sessionItem instanceof Owner) {
+      final HibernateProxy proxy = (HibernateProxy) sessionItem;
+      loaded = !proxy.getHibernateLazyInitializer().isUninitialized();
+    } else {
+      final PersistentBag bag = (PersistentBag) sessionItem;
+      loaded = bag.wasInitialized();
+    }
+    return ResponseEntity.ok(loaded);
+  }
+}

dd-smoke-tests/springboot-jpa/src/main/java/datadog/smoketest/springboot/entity/Author.java

@@ -0,0 +1,31 @@
+package datadog.smoketest.springboot.entity;
+
+import javax.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+@Setter
+@EqualsAndHashCode(of = "id")
+public class Author {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private int id;
+
+  private String name;
+
+  private int updateCount;
+
+  public void increaseUpdateCount() {
+    this.updateCount++;
+  }
+}

dd-smoke-tests/springboot-jpa/src/main/java/datadog/smoketest/springboot/entity/Book.java

@@ -0,0 +1,40 @@
+package datadog.smoketest.springboot.entity;
+
+import java.util.List;
+import javax.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+@Setter
+@EqualsAndHashCode(of = "id")
+public class Book {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private int id;
+
+  private String title;
+
+  @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
+  @JoinColumn(name = "book_id")
+  private List<Author> authors;
+
+  @OneToOne(cascade = CascadeType.ALL, optional = false, fetch = FetchType.LAZY)
+  @JoinColumn(name = "owner_id")
+  private Owner owner;
+
+  private int updateCount;
+
+  public void increaseUpdateCount() {
+    this.updateCount++;
+  }
+}

dd-smoke-tests/springboot-jpa/src/main/java/datadog/smoketest/springboot/entity/Library.java

@@ -0,0 +1,50 @@
+package datadog.smoketest.springboot.entity;
+
+import java.util.List;
+import javax.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+@Setter
+@EqualsAndHashCode(of = "id")
+public class Library {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private int id;
+
+  private String name;
+
+  @OneToMany(cascade = CascadeType.ALL)
+  @JoinColumn(name = "library_id")
+  private List<Book> books;
+
+  private int updateCount;
+
+  public void increaseUpdateCount() {
+    this.updateCount++;
+  }
+
+  public boolean isIssueExists() {
+    for (Book book : this.getBooks()) {
+      if (book.getUpdateCount() != book.getOwner().getUpdateCount()) {
+        return true;
+      }
+      for (Author author : book.getAuthors()) {
+        if (book.getUpdateCount() != author.getUpdateCount()) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+}

dd-smoke-tests/springboot-jpa/src/main/java/datadog/smoketest/springboot/entity/Owner.java

@@ -0,0 +1,34 @@
+package datadog.smoketest.springboot.entity;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+@Setter
+@EqualsAndHashCode(of = "id")
+public class Owner {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private int id;
+
+  private String name;
+
+  private int updateCount;
+
+  public void increaseUpdateCount() {
+    this.updateCount++;
+  }
+}