How to use

draftFromJsonResource

method

in

io.sphere.sdk.test.SphereTestUtils

  @Test
  public void createByJson() {
    final JsonNodeReferenceResolver referenceResolver = new JsonNodeReferenceResolver();
    withCartDiscount(client(), builder -> builder.requiresDiscountCode(true), cartDiscount -> {
      referenceResolver.addResourceByKey("demo-cart-discount", cartDiscount);
      final DiscountCodeDraft draft = draftFromJsonResource("drafts-tests/discountCode.json", DiscountCodeDraft.class, referenceResolver);
      withDiscountCode(client(), draft, discountCode -> {
        assertThat(discountCode.getCode()).isEqualTo("demo-discount-code");
        assertThat(discountCode.getCartDiscounts().get(0)).isEqualTo(cartDiscount.toReference());
        assertThat(discountCode.getCartPredicate()).isEqualTo("lineItemTotal(1 = 1) >  \"10.00 EUR\"");
        assertThat(discountCode.isActive()).isTrue();
      });
    });
  }
}

  @Test
  public void createByJson() {
    withChannelOfRole(client(), INVENTORY_SUPPLY, channel -> {
      final JsonNodeReferenceResolver referenceResolver = new JsonNodeReferenceResolver();
      referenceResolver.addResourceByKey("supply-channel", channel);
      final InventoryEntryDraft draft = draftFromJsonResource("drafts-tests/inventory.json", InventoryEntryDraft.class, referenceResolver);

      InventoryEntryFixtures.withInventoryEntry(client(), draft, inventoryEntry -> {
        assertThat(inventoryEntry.getSku()).isEqualTo("demo-sku");
        assertThat(inventoryEntry.getQuantityOnStock()).isEqualTo(523);
        assertThat(inventoryEntry.getSupplyChannel()).isEqualTo(channel.toReference());
      });
    });

  }
}

  @Test
  @SuppressWarnings({"varargs", "unchecked"})
  public void createByJson() {
    withStateByBuilder(client(), builder -> builder.type(StateType.PRODUCT_STATE), otherState -> {
      final JsonNodeReferenceResolver referenceResolver = new JsonNodeReferenceResolver();
      referenceResolver.addResourceByKey("other-state", otherState);
      final StateDraft draft = draftFromJsonResource("drafts-tests/state.json", StateDraft.class, referenceResolver);
      withState(client(), draft, state -> {
        assertThat(state.getKey()).isEqualTo(KEY);
        assertThat(state.getType()).isEqualTo(StateType.PRODUCT_STATE);
        assertThat(state.isInitial()).isEqualTo(true);
        assertThat(state.getTransitions()).hasSize(1);
      });
    });

  }
}

@Test
public void createByJson() {
  final JsonNodeReferenceResolver referenceResolver = new JsonNodeReferenceResolver();
  withB2cCustomerGroup(client(), customerGroup -> {
    referenceResolver.addResourceByKey("b2c", customerGroup);
    final CustomerDraft customerDraft = draftFromJsonResource("drafts-tests/customer.json", CustomerDraftDsl.class, referenceResolver);
    CustomerFixtures.withCustomer(client(), customerDraft, customer -> {
      assertThat(customer.getLastName()).isEqualTo("Osgood");
      assertThat(customer.getCustomerGroup()).isEqualTo(customerGroup.toReference());
      assertThat(customer.getAddresses()).hasSize(2);
      assertThat(customer.getDefaultShippingAddress().withId(null))
          .isEqualTo(Address.of(DE).withLastName("Osgood").withExternalId("external-ID-DE"));
    });
  });
}

  @Test
  public void createByJson() {
    final JsonNodeReferenceResolver referenceResolver = new JsonNodeReferenceResolver();
    withCategory(client(), parent -> {
      referenceResolver.addResourceByKey("example-category-parent", parent);
      final CategoryDraft categoryDraft = draftFromJsonResource("drafts-tests/category.json", CategoryDraft.class, referenceResolver);
      withCategory(client(), () -> categoryDraft, category -> {
        assertThat(category.getName().get(Locale.ENGLISH)).isEqualTo("example category");
        assertThat(category.getParent().getId()).isEqualTo(parent.getId());
      });
    });
  }
}

  @Test
  public void createByJson() {
    withTaxCategory(client(), taxCategory -> {
      withZone(client(), zone -> {
        final JsonNodeReferenceResolver referenceResolver = new JsonNodeReferenceResolver();
        referenceResolver.addResourceByKey("standard-tax", taxCategory);
        referenceResolver.addResourceByKey("zone-id", zone);
        final ShippingMethodDraft draft = draftFromJsonResource("drafts-tests/shippingMethod.json", ShippingMethodDraft.class, referenceResolver);
        withShippingMethod(client(), draft, shippingMethod -> {
          assertThat(shippingMethod.getName()).isEqualTo("demo shipping method");
          assertThat(shippingMethod.getTaxCategory()).isEqualTo(taxCategory.toReference());
          final ZoneRate zoneRate = shippingMethod.getZoneRates().get(0);
          assertThat(zoneRate.getZone()).isEqualTo(zone.toReference());
          final ShippingRate shippingRate = zoneRate.getShippingRates().get(0);
          assertThat(shippingRate.getPrice()).isEqualTo(EURO_20);
        });
      }, COUNTRY_CODE);
    });
  }
}

final Reference<TaxCategory> taxCategoryReference = product.getTaxCategory();
referenceResolver.addResourceByKey("standard-tax", taxCategoryReference);
final OrderImportDraft orderImportDraft = draftFromJsonResource("drafts-tests/order.json", OrderImportDraft.class, referenceResolver);

referenceResolver.addResourceByKey("sample-product", product);
referenceResolver.addResourceByKey("standard-tax", product.getTaxCategory());
final CartDraft cartDraft = draftFromJsonResource("drafts-tests/cart.json", CartDraft.class, referenceResolver);

referenceResolver.addResourceByKey("review-product", product);
referenceResolver.addResourceByKey("review-customer", customer);
final ReviewDraft reviewDraft = draftFromJsonResource("drafts-tests/review.json", ReviewDraft.class, referenceResolver);

@Test
public void createProductByJsonDraft() throws Exception {
  final JsonNodeReferenceResolver referenceResolver = new JsonNodeReferenceResolver();
  withCategory(client(), category -> {
    withProductType(client(), randomKey(), productType -> {
      withTaxCategory(client(), taxCategory -> {
        withStateByBuilder(client(), stateBuilder -> stateBuilder.initial(true).type(StateType.PRODUCT_STATE), state -> {
          referenceResolver.addResourceByKey("t-shirt-category", category);
          referenceResolver.addResourceByKey("t-shirt-product-type", productType);
          referenceResolver.addResourceByKey("standard-tax", taxCategory);
          referenceResolver.addResourceByKey("initial-product-state", state);
          final ProductDraft productDraft = draftFromJsonResource("drafts-tests/product.json", ProductDraft.class, referenceResolver);
          final Product product = client().executeBlocking(ProductCreateCommand.of(productDraft));
          assertThat(product.getProductType()).isEqualTo(productType.toReference());
          assertThat(product.getTaxCategory()).isEqualTo(taxCategory.toReference());
          assertThat(product.getState()).isEqualTo(state.toReference());
          final ProductData productData = product.getMasterData().getStaged();
          assertThat(productData.getName()).isEqualTo(LocalizedString.ofEnglish("red shirt"));
          assertThat(productData.getCategories()).extracting("id").contains(category.getId());
          client().executeBlocking(ProductDeleteCommand.of(product));
        });
      });
    });
  });
}