public HandlingEvent createHandlingEvent(
        Date completionTime,
        TrackingId trackingId,
        CarrierMovementId carrierMovementId,
        UnLocode unlocode,
        HandlingEvent.Type type)
        throws UnknownTrackingIdException, UnknownCarrierMovementIdException,
            UnknownLocationException {
      Cargo cargo = validateCargoExists(trackingId);
      CarrierMovement carrierMovement = findCarrierMovement(carrierMovementId);
      Location location = findLocation(unlocode);
      Date registrationTime = new Date();

      // Create entity
      UnitOfWork uow = uowf.currentUnitOfWork();
      EntityBuilder<HandlingEvent> builder = uow.newEntityBuilder(HandlingEvent.class);
      HandlingEventState state = builder.instanceFor(HandlingEventState.class);
      state.cargo().set(cargo);

      // TODO: remove next line when query + association is implemented
      state.cargoTrackingId().set(trackingId.idString());

      state.carrierMovement().set(carrierMovement);
      state.location().set(location);
      state.registrationTime().set(registrationTime);
      state.completionTime().set(completionTime);
      state.eventType().set(type);

      return builder.newInstance();
    }
Пример #2
0
 @Test
 public void whenTraceOnMixinImplExpectTwoEntryInEntityStore() throws Exception {
   SomeService sc =
       moduleInstance.serviceFinder().<SomeService>findService(SomeService.class).get();
   assertEquals(123, sc.doSomethingImportant());
   assertEquals(789, sc.doSomethingModeratelyImportant());
   UnitOfWork uow = unitOfWorkFactory.newUnitOfWork();
   try {
     QueryBuilder<TraceRecord> builder = queryBuilderFactory.newQueryBuilder(TraceRecord.class);
     Query<TraceRecord> query = builder.newQuery(uow);
     // IS sorting needed??
     TraceRecord template = templateFor(TraceRecord.class);
     query.orderBy(orderBy(template.methodName()));
     Iterator<TraceRecord> result = query.iterator();
     assertTrue(result.hasNext());
     TraceRecord rec1 = result.next();
     assertEquals("doSomethingImportant", rec1.methodName().get());
     assertTrue(result.hasNext());
     TraceRecord rec2 = result.next();
     assertEquals("doSomethingModeratelyImportant", rec2.methodName().get());
     assertFalse(result.hasNext());
     uow.complete();
   } catch (Exception e) {
     uow.discard();
     throw e;
   } catch (Error e) {
     uow.discard();
     throw e;
   }
 }
Пример #3
0
 @Override
 public void tearDown() throws Exception {
   if (module.isUnitOfWorkActive()) {
     UnitOfWork uow = module.currentUnitOfWork();
     uow.discard();
   }
   super.tearDown();
 }
Пример #4
0
 @Override
 public void passivate() throws Exception {
   UnitOfWork uow = uowf.newUnitOfWork();
   try {
     RootEntity root = rootEntity();
     LOGGER.info("Existing RootEntity: " + root.identity().get());
   } catch (NoSuchEntityException ex) {
     LOGGER.info("No RootEntity");
   }
   uow.complete();
 }
Пример #5
0
  @Test
  public void payAllBills() throws Exception {
    UnitOfWork uow = module.newUnitOfWork(newUsecase("Pay all bills from checking to creditors"));
    try {
      BalanceData source = uow.get(BalanceData.class, CHECKING_ACCOUNT_ID);

      PayBillsContext2 context = module.newObject(PayBillsContext2.class);
      context.bind(source).payBills();
    } finally {
      uow.discard();
    }
  }
      public Subject authenticate(Object credentials) {

        UnitOfWork unitOfWork =
            module
                .unitOfWorkFactory()
                .newUnitOfWork(UsecaseBuilder.newUsecase("Authenticate JMX user"));
        Subject subject = null;

        try {

          if (!(credentials instanceof String[])) {
            // Special case for null so we get a more informative message
            if (credentials == null) {
              throw new SecurityException("Credentials required");
            }
            throw new SecurityException("Credentials should be String[]");
          }

          final String[] aCredentials = (String[]) credentials;
          if (aCredentials.length != 2) {
            throw new SecurityException("Credentials should have 2 elements");
          }

          String username = aCredentials[0];
          String password = aCredentials[1];

          Authentication user = unitOfWork.get(Authentication.class, username);

          if (!user.login(password)) {
            throw new SecurityException("User/password combination not valid.");
          }

          if (((UserAuthentication.Data) user).isAdministrator()) {
            subject =
                new Subject(
                    true,
                    Collections.singleton(new JMXPrincipal(username)),
                    Collections.EMPTY_SET,
                    Collections.EMPTY_SET);
          } else {
            throw new SecurityException("Invalid credentials");
          }

          unitOfWork.complete();

        } catch (Throwable e) {
          unitOfWork.discard();
          throw new SecurityException(e);
        }

        return subject;
      }
 @Override
 public Iterable<TimelineRecord> getNextRecords(int maxResults) {
   SortedSet<TimelineRecord> result = new TreeSet<>();
   UnitOfWork uow = module.currentUnitOfWork();
   String schedulesName = SchedulerMixin.getSchedulesIdentity(scheduler);
   Schedules schedules = uow.get(Schedules.class, schedulesName);
   for (Schedule schedule : schedules.schedules()) {
     Timeline timeline = (Timeline) schedule;
     Iterable<TimelineRecord> lastRecords = timeline.getNextRecords(maxResults);
     Iterables.addAll(result, lastRecords);
   }
   return Iterables.limit(maxResults, result);
 }
  @Test
  public void givenEntityWithImmutableAssociationWhenBuildingThenNoException() throws Exception {
    UnitOfWork unitOfWork = unitOfWorkFactory.newUnitOfWork();
    try {
      PersonEntity father = unitOfWork.newEntity(PersonEntity.class);

      EntityBuilder<PersonEntity> builder = unitOfWork.newEntityBuilder(PersonEntity.class);
      PersonEntity instance = builder.instance();
      instance.father().set(father);
      PersonEntity child = builder.newInstance();
    } finally {
      unitOfWork.discard();
    }
  }
Пример #9
0
 @Override
 public void activate() throws Exception {
   UnitOfWork uow = uowf.newUnitOfWork();
   try {
     RootEntity root = rootEntity();
     LOGGER.info("Will use RootEntity: " + root.identity().get());
   } catch (NoSuchEntityException ex) {
     EntityBuilder<RootEntity> builder =
         uow.newEntityBuilder(RootEntity.class, RootEntity.IDENTITY);
     RootEntity root = builder.newInstance();
     LOGGER.info("Created new RootEntity: " + root.identity().get());
   }
   uow.complete();
 }
  @Override
  public Iterable<TimelineRecord> getRecords(DateTime from, DateTime to) {
    SortedSet<TimelineRecord> result = new TreeSet<>();

    UnitOfWork uow = module.currentUnitOfWork();
    String schedulesName = SchedulerMixin.getSchedulesIdentity(scheduler);
    Schedules schedules = uow.get(Schedules.class, schedulesName);
    for (Schedule schedule : schedules.schedules()) {
      Timeline timeline = (Timeline) schedule;
      Iterable<TimelineRecord> lastRecords = timeline.getRecords(from, to);
      Iterables.addAll(result, lastRecords);
    }
    return result;
  }
Пример #11
0
  @Test
  public void testOperators()
      throws UnitOfWorkCompletionException, ActivationException, AssemblyException {
    SingletonAssembler assembler =
        new SingletonAssembler() {
          @Override
          public void assemble(ModuleAssembly module) throws AssemblyException {
            new EntityTestAssembler().assemble(module);

            module.entities(TestEntity.class);
            module.values(TestValue.class);
            module.forMixin(TestEntity.class).declareDefaults().foo().set("Bar");
            module.forMixin(TestValue.class).declareDefaults().bar().set("Xyz");
          }
        };

    UnitOfWork uow = assembler.module().newUnitOfWork();

    try {
      EntityBuilder<TestEntity> entityBuilder = uow.newEntityBuilder(TestEntity.class, "123");
      entityBuilder.instance().value().set(assembler.module().newValue(TestValue.class));
      TestEntity testEntity = entityBuilder.newInstance();

      uow.complete();
      uow = assembler.module().newUnitOfWork();

      Iterable<TestEntity> entities = Iterables.iterable(testEntity = uow.get(testEntity));

      QueryBuilder<TestEntity> builder = assembler.module().newQueryBuilder(TestEntity.class);

      {
        Specification<Composite> where =
            QueryExpressions.eq(QueryExpressions.templateFor(TestEntity.class).foo(), "Bar");
        Assert.assertTrue(where.satisfiedBy(testEntity));
        System.out.println(where);
      }
      {
        Specification<Composite> where =
            QueryExpressions.eq(
                QueryExpressions.templateFor(TestEntity.class).value().get().bar(), "Xyz");
        Assert.assertTrue(where.satisfiedBy(testEntity));
        System.out.println(where);

        Assert.assertTrue(builder.where(where).newQuery(entities).find().equals(testEntity));
      }
    } finally {
      uow.discard();
    }
  }
Пример #12
0
    @SuppressWarnings("unchecked")
    private <V> V initializeConfigurationInstance(
        ServiceComposite serviceComposite,
        UnitOfWork uow,
        ServiceDescriptor serviceModel,
        String identity)
        throws InstantiationException {
      Module module = api.moduleOf(serviceComposite);
      Usecase usecase = UsecaseBuilder.newUsecase("Configuration:" + me.identity().get());
      UnitOfWork buildUow = module.newUnitOfWork(usecase);

      EntityBuilder<V> configBuilder =
          buildUow.newEntityBuilder(serviceModel.<V>configurationType(), identity);

      // Check for defaults
      String s = identity + ".properties";
      Class<?> type = first(api.serviceDescriptorFor(serviceComposite).types());
      // Load defaults from classpath root if available
      if (type.getResource(s) == null && type.getResource("/" + s) != null) {
        s = "/" + s;
      }
      InputStream asStream = type.getResourceAsStream(s);
      if (asStream != null) {
        try {
          PropertyMapper.map(asStream, (Composite) configBuilder.instance());
        } catch (IOException e1) {
          InstantiationException exception =
              new InstantiationException("Could not read underlying Properties file.");
          exception.initCause(e1);
          throw exception;
        }
      }

      try {
        configBuilder.newInstance();
        buildUow.complete();

        // Try again
        return (V) findConfigurationInstanceFor(serviceComposite, uow);
      } catch (Exception e1) {
        InstantiationException ex =
            new InstantiationException(
                "Could not instantiate configuration, and no Properties file was found ("
                    + s
                    + ")");
        ex.initCause(e1);
        throw ex;
      }
    }
Пример #13
0
  @Test
  public void planActivitiesTest() throws Exception {
    UnitOfWork uow = assembler.unitOfWorkFactory().newUnitOfWork(UsecaseBuilder.newUsecase("Test"));

    try {
      ProjectData project = uow.get(ProjectData.class, PROJECT);

      new FrontloadContext(project).frontloadNetworkFrom(1); // try 2

      uow.complete();
    } catch (Exception e) {
      uow.discard();
      throw e;
    }
  }
Пример #14
0
    @SuppressWarnings("unchecked")
    public <V> V findConfigurationInstanceFor(ServiceComposite serviceComposite, UnitOfWork uow)
        throws InstantiationException {
      ServiceDescriptor serviceModel = api.serviceDescriptorFor(serviceComposite);

      String identity = serviceComposite.identity().get();
      V configuration;
      try {
        configuration = uow.get(serviceModel.<V>configurationType(), identity);
        uow.pause();
      } catch (NoSuchEntityException | EntityTypeNotFoundException e) {
        return (V) initializeConfigurationInstance(serviceComposite, uow, serviceModel, identity);
      }
      return configuration;
    }
Пример #15
0
 public Cargo create(String originUnLocode, String destinationUnLocode, Date arrivalDeadline) {
   TrackingId trackingId = cargoRepository.nextTrackingId();
   Location origin = locationRepository.findLocationByUnLocode(originUnLocode);
   Location destination = locationRepository.findLocationByUnLocode(destinationUnLocode);
   RouteSpecification routeSpecification =
       routeSpecificationFactory.create(origin, destination, arrivalDeadline);
   UnitOfWork uow = uowf.currentUnitOfWork();
   EntityBuilder<Cargo> builder = uow.newEntityBuilder(Cargo.class, trackingId.id().get());
   Cargo.State instanceState = builder.instanceFor(Cargo.State.class);
   instanceState.routeSpecification().set(routeSpecification);
   instanceState.origin().set(origin);
   Cargo cargo = builder.newInstance();
   logger.info("Booked new cargo with tracking id " + cargo.trackingId().id().get());
   return cargo;
 }
Пример #16
0
  @Test
  public void testIllustrationFactory() throws UnitOfWorkCompletionException {

    UnitOfWork uow = unitOfWorkFactory.newUnitOfWork();

    IllustrationFactory illuFactory =
        (IllustrationFactory) serviceLocator.findService(IllustrationFactory.class).get();

    IllustrationEntity illu = (IllustrationEntity) illuFactory.create("Tagada Tsoin tsoin");

    System.out.println(illu.identity().get());
    System.out.println(illu.name().get());
    System.out.println(illu.creationDate().get());

    uow.complete();
  }
  @Test
  public void givenEntityWithImmutableManyAssociationWhenBuildingThenNoException()
      throws Exception {
    UnitOfWork unitOfWork = unitOfWorkFactory.newUnitOfWork();
    try {
      EntityBuilder<PersonEntity> builder = unitOfWork.newEntityBuilder(PersonEntity.class);
      PersonEntity person1 = builder.instance();
      person1 = builder.newInstance();

      builder = unitOfWork.newEntityBuilder(PersonEntity.class);
      PersonEntity person2 = builder.instance();
      person2.colleagues().add(0, person1);
      person2 = builder.newInstance();
    } finally {
      unitOfWork.discard();
    }
  }
Пример #18
0
 @Override
 public synchronized void refresh() {
   if (configuration != null) {
     configuration = null;
     uow.discard();
     uow = null;
   }
 }
Пример #19
0
 @Test
 public void whenTraceOnMixinTypeMethodExpectOneEntryInEntityStore() throws Exception {
   SomeService sc =
       moduleInstance.serviceFinder().<SomeService>findService(SomeService.class).get();
   assertEquals(123, sc.doSomethingImportant());
   assertEquals(456, sc.doSomethingLessImportant());
   UnitOfWork uow = unitOfWorkFactory.newUnitOfWork();
   QueryBuilder<TraceRecord> builder = queryBuilderFactory.newQueryBuilder(TraceRecord.class);
   Query<TraceRecord> query = builder.newQuery(uow);
   // IS sorting needed??
   //        TraceRecord template = templateFor( TraceRecord.class );
   //        query.orderBy( orderBy( template.methodName() ) );
   Iterator<TraceRecord> result = query.iterator();
   assertTrue(result.hasNext());
   TraceRecord rec1 = result.next();
   assertEquals("doSomethingImportant", rec1.methodName().get());
   assertFalse(result.hasNext());
   uow.complete();
 }
Пример #20
0
  @After
  public void printResult() throws Exception {
    UnitOfWork uow = assembler.unitOfWorkFactory().newUnitOfWork(newUsecase("Print Gantt chart"));

    try {
      List<ActivityData> activities = uow.get(ProjectData.class, PROJECT).allActivities();

      StringBuilder sb = new StringBuilder();
      sb.append("\n\n### Gantt chart showing planned activities:\n");
      Collections.sort(
          activities,
          new Comparator<ActivityData>() {
            public int compare(ActivityData a1, ActivityData a2) {
              if (a1.earlyStart().get().equals(a2.earlyStart().get()))
                return getEntityReference(a1)
                    .identity()
                    .compareTo(getEntityReference(a2).identity());
              else return a1.earlyStart().get() - a2.earlyStart().get();
            }
          });

      for (ActivityData activity : activities) {
        String id = EntityReference.getEntityReference(activity).identity();
        Integer start = activity.earlyStart().get();
        Integer duration = activity.duration().get();
        for (int i = 1; i < start; i++) {
          sb.append("  ");
        }
        sb.append(id);
        for (int i = 0; i < duration - 1; i++) {
          sb.append(" =");
        }
        sb.append("\n");
      }

      sb.append("1 2 3 4 5 6 7 8 9");
      System.out.println(sb.toString());
    } finally {
      uow.discard();
    }
    System.out.println("----------------------------------------------------------");
  }
  @Test(expected = IllegalStateException.class)
  public void givenEntityWithImmutableAssociationWhenChangingValueThenThrowException()
      throws Exception {
    UnitOfWork unitOfWork = unitOfWorkFactory.newUnitOfWork();
    try {
      EntityBuilder<PersonEntity> builder = unitOfWork.newEntityBuilder(PersonEntity.class);
      PersonEntity father = builder.instance();
      father = builder.newInstance();

      builder = unitOfWork.newEntityBuilder(PersonEntity.class);
      PersonEntity child = builder.instance();
      child = builder.newInstance();

      child.father().set(father);

      unitOfWork.complete();
    } catch (Exception e) {
      unitOfWork.discard();
      throw e;
    }
  }
Пример #22
0
  @Test
  public void whenTraceOnConcernExpectOneEntryInEntityStore() throws Exception {
    // It is not possible to put Annotation on Concern Methods, so it should only record one.

    SomeService sc =
        moduleInstance.serviceFinder().<SomeService>findService(SomeService.class).get();
    assertEquals(123, sc.doSomethingImportant());
    assertEquals(753, sc.doSomethingInsanelyImportant());
    UnitOfWork uow = unitOfWorkFactory.newUnitOfWork();
    QueryBuilder<TraceRecord> builder = queryBuilderFactory.newQueryBuilder(TraceRecord.class);
    Query<TraceRecord> query = builder.newQuery(uow);
    // IS sorting needed??
    //        TraceRecord template = templateFor( TraceRecord.class );
    //        query.orderBy( orderBy( template.methodName() ) );
    Iterator<TraceRecord> result = query.iterator();
    assertTrue(result.hasNext());
    TraceRecord rec1 = result.next();
    assertEquals("doSomethingImportant", rec1.methodName().get());
    assertFalse(result.hasNext());
    uow.complete();
  }
  @Test(expected = IllegalStateException.class)
  public void givenEntityWithImmutableManyAssociationWhenChangingValueThenThrowException()
      throws Exception {
    UnitOfWork unitOfWork = unitOfWorkFactory.newUnitOfWork();
    try {
      EntityBuilder<PersonEntity> builder = unitOfWork.newEntityBuilder(PersonEntity.class);
      PersonEntity person1 = builder.instance();
      person1 = builder.newInstance();

      builder = unitOfWork.newEntityBuilder(PersonEntity.class);
      PersonEntity person2 = builder.instance();
      person2 = builder.newInstance();

      person1.colleagues().add(0, person2);

      unitOfWork.complete();
    } catch (Exception e) {
      unitOfWork.discard();
      throw e;
    }
  }
Пример #24
0
 public Voyage build() {
   final ValueBuilder<Schedule> builder = factory.newValueBuilder(Schedule.class);
   builder.prototype().carrierMovements().set(carrierMovements);
   final Schedule schedule = builder.newInstance();
   final EntityBuilder<Voyage> entityBuilder =
       uow.newEntityBuilder(Voyage.class, createVoyageIdentity(voyageNumberString));
   Voyage voyage = entityBuilder.instance();
   VoyageNumber voyageNumber = createVoyageNumber(voyageNumberString);
   voyage.voyageNumber().set(voyageNumber);
   voyage.schedule().set(schedule);
   return entityBuilder.newInstance();
 }
Пример #25
0
  private static void buildDemoNetwork(SingletonAssembler assembler) throws Exception {
    UnitOfWork uow =
        assembler.unitOfWorkFactory().newUnitOfWork(newUsecase("Build demo network of activities"));
    try {
      // try different combinations here...

      ActivityEntity a = uow.newEntity(ActivityEntity.class, "A");
      ActivityEntity b = uow.newEntity(ActivityEntity.class, "B");
      ActivityEntity c = uow.newEntity(ActivityEntity.class, "C");
      ActivityEntity d = uow.newEntity(ActivityEntity.class, "D");

      a.duration().set(2);
      b.duration().set(7);
      c.duration().set(3);
      d.duration().set(2);

      a.succeededBy(c, d);

      // Try different variations:
      b.succeededBy(d); // "Original"
      //         b.succeededBy( c );     // Variation
      //         c.succeededBy( a );     // "C" already planned
      //         d.succeededBy( a );     // Cyclic dependency

      ProjectData project = uow.newEntity(ProjectData.class, PROJECT);
      //         project.addActivities( a, b, c, d );
      project.addActivities(d, c, b, a); // More interesting execution flow

      // Save
      uow.complete();
    } catch (Exception e) {
      uow.discard();
      throw e;
    }
  }
Пример #26
0
 // WARN Watch this code, see if we can do better, maybe leverage @UnitOfWorkRetry
 @Override
 public void run() {
   System.out.println("Running Schedule");
   Usecase usecase = UsecaseBuilder.newUsecase("ScheduleRunner");
   UnitOfWork uow = module.newUnitOfWork(usecase);
   try {
     Schedule schedule = uow.get(Schedule.class, this.schedule.scheduleIdentity);
     Task task = schedule.task().get();
     schedule = uow.get(Schedule.class, this.schedule.scheduleIdentity);
     try {
       schedule.taskStarting();
       task.run();
       schedule.taskCompletedSuccessfully();
     } catch (RuntimeException ex) {
       schedule.taskCompletedWithException(ex);
     }
     schedulerMixin.dispatchForExecution(schedule);
     uow.complete();
   } catch (UnitOfWorkCompletionException ex) {
   } finally {
     // What should we do if we can't manage the Running flag??
     if (uow.isOpen()) {
       uow.discard();
     }
   }
 }
Пример #27
0
    @Override
    public void save() {
      if (uow != null) {
        try {
          uow.complete();
          uow = null;
        } catch (UnitOfWorkCompletionException e) {
          // Should be impossible
          e.printStackTrace();
        }

        configuration = null; // Force refresh
      }
    }
Пример #28
0
  @Test(expected = IllegalArgumentException.class)
  public void transferTwiceOfMoneyFromSavingsToChecking() throws Exception {
    UnitOfWork uow =
        module.newUnitOfWork(UsecaseBuilder.newUsecase("Transfer from savings to checking"));

    try {
      // Select source and destination
      BalanceData source = uow.get(BalanceData.class, SAVINGS_ACCOUNT_ID);
      BalanceData destination = uow.get(BalanceData.class, CHECKING_ACCOUNT_ID);

      // Instantiate context and execute enactments with that context
      TransferMoneyContext2 context =
          module.newTransient(TransferMoneyContext2.class).bind(source, destination);

      // Query for double the balance
      final Integer amountToTransfer = context.availableFunds() * 2;

      // Transfer from savings to checking
      context.transfer(amountToTransfer);
    } finally {
      uow.discard();
    }
  }
  @Test
  public void createAndModifyEntity() throws Exception {
    UnitOfWork uow = this.module.newUnitOfWork();
    TestEntity entity = uow.newEntity(TestEntity.class);
    uow.complete();

    uow = this.module.newUnitOfWork();
    entity = uow.get(entity);
    entity.testString().set("NewTestString");
    uow.complete();

    uow = this.module.newUnitOfWork();
    entity = uow.get(entity);
    Assert.assertEquals(
        "New value did not store in indexing.", "NewTestString", entity.testString().get());
    uow.discard();
  }
Пример #30
0
    public void activate() throws Exception {
      UnitOfWork unitOfWork = uowf.newUnitOfWork();
      try {
        {
          ValueBuilder<TestValue> valueBuilder = vbf.newValueBuilder(TestValue.class);
          valueBuilder.prototype().longList().get().add(42L);
          valueBuilder.prototype().string().set("Foo bar value");
          valueBuilder.prototype().map().set(new HashMap());

          EntityBuilder<TestEntity> builder =
              unitOfWork.newEntityBuilder(TestEntity.class, "test1");
          builder.instance().name().set("Foo bar");
          builder.instance().age().set(42);
          builder.instance().value().set(valueBuilder.newInstance());
          TestEntity testEntity = builder.newInstance();

          EntityBuilder<TestEntity> builder2 =
              unitOfWork.newEntityBuilder(TestEntity.class, "test2");
          builder2.instance().name().set("Xyzzy");
          builder2.instance().age().set(12);
          builder2.instance().association().set(testEntity);
          builder2.instance().manyAssociation().add(0, testEntity);
          builder2.instance().manyAssociation().add(0, testEntity);

          EntityBuilder<TestRole> builder3 = unitOfWork.newEntityBuilder(TestRole.class);
          builder3.instance().name().set("A role");
          TestRole testRole = builder3.newInstance();

          builder2.newInstance();
        }

        {
          EntityBuilder<TestEntity2> builder =
              unitOfWork.newEntityBuilder(TestEntity2.class, "test3");
          builder.instance().name().set("Test3");
          builder.newInstance();
        }

        unitOfWork.complete();
      } catch (Exception e) {
        unitOfWork.discard();
        throw e;
      }
    }