예제 #1
0
  @Test
  public void testUpdateAndDeleteOfChildren() {
    final Library lib = createTestData();
    {
      String content =
          doGetRequest(
              LibraryModelPackage.INSTANCE.getLibraryEClass().getName(),
              null,
              HttpServletResponse.SC_OK);
      final List<Object> objects = deserialize(content);
      Assert.assertEquals(1, objects.size());
      final ResponseType responseType = (ResponseType) objects.get(0);
      final Library libResult = (Library) responseType.getData().get(0);
      Assert.assertNotSame(lib, libResult);
      Assert.assertEquals(lib.getDb_Id(), libResult.getDb_Id());

      // now remove parts from the library
      Writer w = libResult.getWriters().get(0);
      libResult.getBooks().removeAll(w.getBooks());
      libResult.getWriters().remove(w);
      libResult.setName("updated"); // $NON-NLS-1$
      content = serialize(libResult);
      doContentRequest(
          getObjectUrlPart(libResult), content, HttpServletResponse.SC_OK, null, HttpMethod.PUT);
      checkExists(w, false);
      for (Book bk : w.getBooks()) {
        checkExists(bk, false);
      }
    }

    // check that the name of the library got updated
    {
      String content =
          doGetRequest(
              LibraryModelPackage.INSTANCE.getLibraryEClass().getName(),
              null,
              HttpServletResponse.SC_OK);
      final List<Object> objects = deserialize(content);
      Assert.assertEquals(1, objects.size());
      final ResponseType responseType = (ResponseType) objects.get(0);
      final Library resultLib = (Library) responseType.getData().get(0);
      Assert.assertEquals("updated", resultLib.getName()); // $NON-NLS-1$
    }
  }
예제 #2
0
  private Library createTestDataInstance() {
    final LibraryModelFactory factory = LibraryModelPackage.MODELFACTORY;
    final int COUNT = 5;

    // create testdata
    final Library lib = factory.createLibrary();
    lib.setName("name"); // $NON-NLS-1$

    for (int w = 0; w < COUNT; w++) {
      final Writer writer = factory.createWriter();
      lib.getWriters().add(writer);

      for (int b = 0; b < COUNT; b++) {
        final Book bk = factory.createBook();
        bk.setAuthor(writer);
        writer.getBooks().add(bk);
        lib.getBooks().add(bk);
      }
    }
    return lib;
  }
예제 #3
0
  @Test
  public void testRetrievalAndDelete() {
    final Library lib = createTestData();

    // children
    final Writer w = lib.getWriters().get(0);
    final Book bk = lib.getBooks().get(0);

    // get model information
    if (!isXmlTest()) {
      {
        final String content =
            doGetRequest("model/epackage?id=library", null, HttpServletResponse.SC_OK);
        final List<Object> objects = deserialize(content);
        Assert.assertEquals(1, objects.size());
        Assert.assertTrue(objects.get(0) instanceof DynamicModelObject);
        final DynamicModelObject dmo = (DynamicModelObject) objects.get(0);
        Assert.assertTrue(dmo.eClass() == EcorePackage.eINSTANCE.getEPackage());
        Assert.assertEquals("library", dmo.eGet(EcorePackage.eINSTANCE.getENamedElement_Name()));
        Assert.assertEquals(
            LibraryModelPackage.NS_URI, dmo.eGet(EcorePackage.eINSTANCE.getEPackage_NsURI()));
      }

      {
        final String content =
            doGetRequest(
                "model/epackage?id=" + LibraryModelPackage.NS_URI, null, HttpServletResponse.SC_OK);
        final List<Object> objects = deserialize(content);
        Assert.assertEquals(1, objects.size());
        Assert.assertTrue(objects.get(0) instanceof DynamicModelObject);
        final DynamicModelObject dmo = (DynamicModelObject) objects.get(0);
        Assert.assertTrue(dmo.eClass() == EcorePackage.eINSTANCE.getEPackage());
        Assert.assertEquals("library", dmo.eGet(EcorePackage.eINSTANCE.getENamedElement_Name()));
        Assert.assertEquals(
            LibraryModelPackage.NS_URI, dmo.eGet(EcorePackage.eINSTANCE.getEPackage_NsURI()));
      }

      {
        final String content =
            doGetRequest(
                "model/eclass?name=Book&epackage=" + LibraryModelPackage.NS_URI,
                null,
                HttpServletResponse.SC_OK);
        final List<Object> objects = deserialize(content);
        Assert.assertEquals(1, objects.size());
        Assert.assertTrue(objects.get(0) instanceof DynamicModelObject);
        final DynamicModelObject dmo = (DynamicModelObject) objects.get(0);
        Assert.assertTrue(dmo.eClass() == EcorePackage.eINSTANCE.getEClass());
        Assert.assertEquals("Book", dmo.eGet(EcorePackage.eINSTANCE.getENamedElement_Name()));
      }

      {
        final String content =
            doGetRequest(
                "model/eclassifier?name=BookCategory&epackage=" + LibraryModelPackage.NS_URI,
                null,
                HttpServletResponse.SC_OK);
        final List<Object> objects = deserialize(content);
        Assert.assertEquals(1, objects.size());
        Assert.assertTrue(objects.get(0) instanceof DynamicModelObject);
        final DynamicModelObject dmo = (DynamicModelObject) objects.get(0);
        Assert.assertTrue(dmo.eClass() == EcorePackage.eINSTANCE.getEEnum());
        Assert.assertEquals(
            "BookCategory", dmo.eGet(EcorePackage.eINSTANCE.getENamedElement_Name()));
      }
    }
    // get all libraries
    {
      final String content =
          doGetRequest(
              LibraryModelPackage.INSTANCE.getLibraryEClass().getName(),
              null,
              HttpServletResponse.SC_OK);
      final List<Object> objects = deserialize(content);
      Assert.assertEquals(1, objects.size());
      final ResponseType responseType = (ResponseType) objects.get(0);
      final Library libResult = (Library) responseType.getData().get(0);
      Assert.assertNotSame(lib, libResult);
      Assert.assertEquals(lib.getDb_Id(), libResult.getDb_Id());
    }

    // get one library, and call its content
    {
      String content = getOneObject(lib);
      getValidateOneObject(lib);

      System.err.println(content);
      // and all its content
      final ModelObject<?> modelObject = ModelResolver.getInstance().getModelObject(lib);
      for (EReference eReference : modelObject.eClass().getEAllReferences()) {
        final Object value = modelObject.eGet(eReference);
        if (value == null) {
          continue;
        }
        if (eReference.isMany()) {
          for (Object element : (List<?>) value) {
            if (element instanceof Identifiable) {
              getValidateOneObject(element);
            }
          }
        } else {
          if (value instanceof Identifiable) {
            getValidateOneObject(value);
          }
        }
      }
    }

    // now delete the library
    doDeleteRequest(
        LibraryModelPackage.INSTANCE.getLibraryEClass().getName() + "/" + lib.getDb_Id(),
        HttpServletResponse.SC_OK); // $NON-NLS-1$
    // this should fail
    {
      final String content =
          doGetRequest(
              LibraryModelPackage.INSTANCE.getLibraryEClass().getName() + "/" + lib.getDb_Id(),
              null,
              HttpServletResponse.SC_NOT_FOUND); // $NON-NLS-1$
      final List<Object> objects = deserialize(content);
      Assert.assertEquals(1, objects.size());
      final ErrorType errorType = (ErrorType) objects.get(0);
      Assert.assertTrue(errorType.getMessage().contains("Resource not found")); // $NON-NLS-1$
    }

    // children are removed
    checkExists(w, false);
    checkExists(bk, false);
  }
예제 #4
0
  @Test
  public void insertComplexStructureTest() throws Exception {
    Library lib = null;
    {
      final String content = serialize(createTestDataInstance());
      final String resultStr =
          doContentRequest(
              ModelUtils.getQualifiedNameFromEClass(LibraryModelPackage.INSTANCE.getWriterEClass()),
              content,
              HttpServletResponse.SC_OK,
              null,
              HttpMethod.POST);
      final ResultType result = (ResultType) deserialize(resultStr).get(0);
      lib = (Library) result.getInserted().get(0);
      Assert.assertTrue(lib.getDb_Id() != null);
      for (Book bk : lib.getBooks()) {
        Assert.assertTrue(bk.getDb_Id() != null);
        checkExists(bk, true);
      }
      for (Writer w : lib.getWriters()) {
        Assert.assertTrue(w.getDb_Id() != null);
        checkExists(w, true);
      }
    }

    // remove all books
    Writer w = lib.getWriters().get(0);
    final String newName = "" + System.currentTimeMillis(); // $NON-NLS-1$
    w.setName(newName);
    final Book bk = w.getBooks().get(0);
    w.getBooks().clear();

    {
      final String content = serialize(w);
      final String resultStr =
          doContentRequest(
              ModelUtils.getQualifiedNameFromEClass(LibraryModelPackage.INSTANCE.getWriterEClass()),
              content,
              HttpServletResponse.SC_OK,
              null,
              HttpMethod.POST);
      final ResultType resultType = (ResultType) deserialize(resultStr).get(0);
      final Writer wResult = (Writer) resultType.getUpdated().get(0);
      Assert.assertNotSame(w, wResult);
      Assert.assertEquals(w.getDb_Id(), wResult.getDb_Id());
      Assert.assertEquals(0, wResult.getBooks().size());

      // use the new writer as the version may have changed
      w = wResult;
      checkExists(w, true);
    }

    {
      final String content =
          doGetRequest(
              ModelUtils.getQualifiedNameFromEClass(LibraryModelPackage.INSTANCE.getWriterEClass()),
              null,
              HttpServletResponse.SC_OK);
      final List<Object> objects = deserialize(content);
      System.err.println(objects.size());
    }

    // and add one book again
    {
      w.getBooks().add(bk);
      bk.setAuthor(w);
      final String content = serialize(w);
      final String resultStr =
          doContentRequest(
              ModelUtils.getQualifiedNameFromEClass(LibraryModelPackage.INSTANCE.getWriterEClass()),
              content,
              HttpServletResponse.SC_OK,
              null,
              HttpMethod.POST);
      final ResultType resultType = (ResultType) deserialize(resultStr).get(0);
      final Writer wResult = (Writer) resultType.getUpdated().get(0);
      Assert.assertNotSame(w, wResult);
      Assert.assertEquals(w.getDb_Id(), wResult.getDb_Id());
      Assert.assertEquals(1, wResult.getBooks().size());
      // disabled test as books of a writer are proxied
      // Assert.assertEquals(wResult.getBooks().get(0).getAuthor(), wResult);
    }

    {
      final Writer w2 = (Writer) deserialize(getOneObject(w)).get(0);
      Assert.assertNotSame(w, w2);
      Assert.assertEquals(newName, w2.getName());
      Assert.assertEquals(w.getDb_Id(), w2.getDb_Id());
      Assert.assertEquals(1, w2.getBooks().size());
      Assert.assertEquals(bk.getDb_Id(), w2.getBooks().get(0).getDb_Id());
    }
  }