Пример #1
0
  /** Test isExtramural method. */
  public void testIsExtramural2() throws Exception {

    RegistryObject mySourceObject = lcm.createRegistryPackage("testIsExtramural mySourceObject");
    RegistryObject myTargetObject = lcm.createRegistryPackage("testIsExtramural myTargetObject");

    RegistryObject othersObject =
        dqm.getRegistryObject(
            BindingUtility.CANONICAL_CLASSIFICATION_SCHEME_ID_ObjectType,
            LifeCycleManager.CLASSIFICATION_SCHEME);

    Concept assocType =
        (Concept)
            dqm.getRegistryObject(
                BindingUtility.CANONICAL_ASSOCIATION_TYPE_ID_RelatedTo, LifeCycleManager.CONCEPT);

    // Create an extramural assoc
    Association extramuralAss = lcm.createAssociation(othersObject, assocType);
    mySourceObject.addAssociation(extramuralAss);

    // Create an intramural assoc
    Association intramuralAss = lcm.createAssociation(myTargetObject, assocType);
    mySourceObject.addAssociation(intramuralAss);

    ArrayList objects = new ArrayList();
    objects.add(mySourceObject);
    objects.add(myTargetObject);
    lcm.saveObjects(objects);

    mySourceObject =
        dqm.getRegistryObject(mySourceObject.getKey().getId(), LifeCycleManager.REGISTRY_PACKAGE);
    myTargetObject =
        dqm.getRegistryObject(myTargetObject.getKey().getId(), LifeCycleManager.REGISTRY_PACKAGE);

    extramuralAss =
        (Association)
            dqm.getRegistryObject(extramuralAss.getKey().getId(), LifeCycleManager.ASSOCIATION);
    assertTrue(
        "isExtraMural return false for extramural Association", (extramuralAss.isExtramural()));

    intramuralAss =
        (Association)
            dqm.getRegistryObject(intramuralAss.getKey().getId(), LifeCycleManager.ASSOCIATION);
    assertFalse(
        "isExtraMural return true for intramural Association", (intramuralAss.isExtramural()));
  }
Пример #2
0
  public void testDeleteAssociationTarget() throws Exception {
    String mySourceObjectId =
        "urn:freebxml:registry:test:AssociationTest.testDeleteAssociationTarget:srcpkg";
    String myTargetObjectId =
        "urn:freebxml:registry:test:AssociationTest.testDeleteAssociationTarget:tgtpkg";
    String myAssocId =
        "urn:freebxml:registry:test:AssociationTest.testDeleteAssociationTarget:assoc";

    // pre test clean-up
    deleteIfExist(mySourceObjectId, LifeCycleManager.REGISTRY_PACKAGE);
    deleteIfExist(myTargetObjectId, LifeCycleManager.REGISTRY_PACKAGE);
    deleteIfExist(myAssocId, LifeCycleManager.ASSOCIATION);

    RegistryObject mySourceObject =
        lcm.createRegistryPackage("testDeleteAssociationTarget mySourceObject");
    RegistryObject myTargetObject =
        lcm.createRegistryPackage("testDeleteAssociationTarget myTargetObject");
    mySourceObject.setKey(lcm.createKey(mySourceObjectId));
    myTargetObject.setKey(lcm.createKey(myTargetObjectId));

    Concept assocType =
        (Concept)
            dqm.getRegistryObject(
                BindingUtility.CANONICAL_ASSOCIATION_TYPE_ID_RelatedTo, LifeCycleManager.CONCEPT);

    // Create an assoc
    Association myAssoc = lcm.createAssociation(myTargetObject, assocType);
    myAssoc.setKey(lcm.createKey(myAssocId));
    mySourceObject.addAssociation(myAssoc);

    Collection saveObjects = new ArrayList();
    saveObjects.add(mySourceObject);
    saveObjects.add(myTargetObject);
    saveObjects.add(myAssoc);
    BulkResponse br = lcm.saveObjects(saveObjects, dontVersionSlotsMap);
    assertResponseSuccess("Saving test objects failed.", br);

    try {

      br =
          lcm.deleteObjects(
              Collections.singletonList(myTargetObject.getKey()),
              null,
              forceRemoveRequestSlotsMap,
              null);
      assertResponseSuccess("Deleting assoc.target failed.", br);

      RegistryObject gotSource =
          bqm.getRegistryObject(mySourceObjectId, LifeCycleManager.REGISTRY_PACKAGE);
      assertNotNull("Association source was also deleted", gotSource);

      RegistryObject gotTarget =
          bqm.getRegistryObject(myTargetObjectId, LifeCycleManager.REGISTRY_PACKAGE);
      assertNull("Target was not deleted", gotTarget);

      RegistryObject gotAssoc = bqm.getRegistryObject(myAssocId, LifeCycleManager.ASSOCIATION);
      assertNull(
          "This is a known failure that needs to be investigated and fixed. "
              + "Association was not deleted",
          gotAssoc);

    } finally {
      // post test clean-up
      deleteIfExist(mySourceObjectId, LifeCycleManager.REGISTRY_PACKAGE);
      deleteIfExist(myTargetObjectId, LifeCycleManager.REGISTRY_PACKAGE);
      deleteIfExist(myAssocId, LifeCycleManager.ASSOCIATION);
    }
  }
Пример #3
0
  /**
   * Create and save an organization. Create and save a service. Request only service be returned.
   * Verify that only the service is returned.
   */
  public void testgetRegistryObjectsSpecifiedType() throws Exception {

    Key orgkey = null;
    String myServiceName = "TCK_TEST_SERVICE";
    Collection orgKeys = null;
    boolean pass = false;

    try {
      System.out.println("Create a service and an organization \n");
      Service service = lcm.createService(myServiceName);
      Collection myServices = new ArrayList();

      // create an organization
      Organization org = (Organization) lcm.createObject(lcm.ORGANIZATION);

      org.setName(lcm.createInternationalString("CTS_Test_ORG"));
      // publish the organization
      Collection orgs = new ArrayList();
      orgs.add(org);
      System.out.println("Save the organization and get the key id from getCollection\n");
      BulkResponse br = lcm.saveOrganizations(orgs); // publish to registry

      orgKeys = br.getCollection();
      Iterator iter = orgKeys.iterator();
      while (iter.hasNext()) {
        orgkey = (Key) iter.next();
      }
      String orgKeyId = orgkey.getId();
      System.out.println("Saved Organization key id is: " + orgKeyId + "\n");
      System.out.println("Call getRegistryObjects to get all owned objects\n");
      br = bqm.getRegistryObjects();
      System.out.println("Find the saved organization and add the service to it \n");
      // get the org back
      Collection ros = br.getCollection();
      Organization o = null;
      iter = ros.iterator();
      String regKeyId = null;
      while (iter.hasNext()) {
        Object obj = iter.next();
        if (obj instanceof Organization) {
          o = (Organization) obj;
          if (o.getKey().getId().equals(orgKeyId)) {
            System.out.println("Found the organization\n");
            regKeyId = o.getKey().getId();
            o.addService(service);
            myServices.add(service);
            break;
          }
        }
      }
      if (o == null) {
        System.out.println("Error: failed to get the Organization with getRegistryObjects \n");
      }
      // ==
      System.out.println("save the service to the registry \n");
      br = lcm.saveServices(myServices);
      Key servicekey = null;
      Collection serviceKeys = br.getCollection();
      System.out.println(
          "The number of service keys returned from getCollection is: "
              + serviceKeys.size()
              + "\n");
      iter = serviceKeys.iterator();
      while (iter.hasNext()) {
        servicekey = (Key) iter.next();
      }
      System.out.println("Save the service key returned from saveServices\n");
      String serviceKeyId = servicekey.getId();
      System.out.println("Saved Service key id is: " + serviceKeyId + "\n");
      System.out.println(
          "request service objects with getRegistryObjects(LifeCycleManager.SERVICE) \n");
      br = bqm.getRegistryObjects(LifeCycleManager.SERVICE);
      // br = bqm.getRegistryObjects();

      Collection myObjects = br.getCollection();
      System.out.println(
          "Count of objects returned from service request is: " + myObjects.size() + "\n");
      if (myObjects.size() == 0)
        System.out.println(" failed - nothing returned from getRegistryObjects");

      iter = myObjects.iterator();
      RegistryObject ro = null;

      while (iter.hasNext()) {
        ro = (RegistryObject) iter.next();
        if (ro instanceof Service) {
          System.out.println(" ro is a Service \n");
          if (ro.getKey().getId().equals(serviceKeyId)) {
            System.out.println("Got back my service - Good! \n");
            pass = true;
          }
        } else if (!(ro instanceof Service)) {
          System.out.println(" returned ro not a service! " + ro.toString() + "\n");
        }
      }

    } catch (Exception e) {
      System.out.println("Caught exception: " + e.getMessage());
      e.printStackTrace();
    } finally {
      System.out.println("cleanup at test end \n");
      // super.cleanUpRegistry(orgKeys, LifeCycleManager.ORGANIZATION);
    }

    assert (pass);
  }