tests/org.eclipse.wst.ws.tests/tests/org/eclipse/wst/ws/tests/unittest/RegistryTests.java - webservices/webtools.webservices - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2007 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.wst.ws.tests.unittest;

 import java.io.File;

 import junit.framework.Assert;
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;

 import org.eclipse.emf.common.util.EList;
 import org.eclipse.wst.ws.internal.model.v10.registry.Name;
 import org.eclipse.wst.ws.internal.model.v10.registry.Registry;
 import org.eclipse.wst.ws.internal.model.v10.registry.RegistryFactory;
 import org.eclipse.wst.ws.internal.model.v10.taxonomy.Category;
 import org.eclipse.wst.ws.internal.model.v10.taxonomy.Taxonomy;
 import org.eclipse.wst.ws.internal.model.v10.taxonomy.TaxonomyFactory;
 import org.eclipse.wst.ws.internal.model.v10.uddiregistry.Taxonomies;
 import org.eclipse.wst.ws.internal.model.v10.uddiregistry.UDDIRegistry;
 import org.eclipse.wst.ws.internal.model.v10.uddiregistry.UDDIRegistryFactory;
 import org.eclipse.wst.ws.internal.registry.IRegistryManager;
 import org.eclipse.wst.ws.internal.registry.RegistryService;
 import org.eclipse.wst.ws.internal.registry.UDDIRegistryService;

 public class RegistryTests extends TestCase
 {
 	public static Test suite ()
 	{
 		return new TestSuite(RegistryTests.class);
 	}

 	/**
 	 * Creates a new Taxonomy model and passes it to
 	 * <code>RegistryService.saveTaxonomy()</code>
 	 * where the model is persisted to a platform
 	 * specified temporary filesystem location.
 	 */
 	public void test_RegistryService_saveTaxonomy ()
 	{
 		System.out.println("STARTING test_RegistryService_saveTaxonomy");
 		try
 		{
 			System.out.println("Creating RegistryService and Taxonomy");
 			RegistryService registryService = RegistryService.instance();
 			Taxonomy taxonomy = registryService.newTaxonomy();

 			System.out.println("Building a simple Taxonomy model");
 			taxonomy.setId("my.taxonomy");
 			taxonomy.setName("My Taxonomy");
 			EList list = taxonomy.getCategory();
 			Category category1 = TaxonomyFactory.eINSTANCE.createCategory();
 			category1.setName("My first category");
 			category1.setCode("1");
 			Category category2 = TaxonomyFactory.eINSTANCE.createCategory();
 			category2.setName("My second category");
 			category2.setCode("2");
 			Category category3 = TaxonomyFactory.eINSTANCE.createCategory();
 			category3.setName("My third category");
 			category3.setCode("2.1");
 			category2.getCategory().add(category3);
 			list.add(category1);
 			list.add(category2);

 			File file = File.createTempFile("taxonomy.",".xml");
 			System.out.println("Saving the Taxonomy model to "+file.getCanonicalPath());
 			registryService.saveTaxonomy(file.toURL(),taxonomy);
 		}
 		catch (Exception exc)
 		{
 			exc.printStackTrace();
 			fail("Unexpected Throwable ["+exc.getMessage()+"]");
 		}
 		finally
 		{
 			System.out.println("FINISHED test_RegistryService_saveTaxonomy\n");
 		}
 	}

 	/**
 	 * Creates a new UDDI Registry model and passes it to
 	 * <code>RegistryService.saveRegistry()</code>
 	 * where the model is persisted to a platform
 	 * specified temporary filesystem location.
 	 */
 	public void test_RegistryService_saveRegistry ()
 	{
 		System.out.println("STARTING test_RegistryService_saveRegistry");
 		try
 		{
 			System.out.println("Creating RegistryService, UDDIRegistryService and Registry");
 			RegistryService registryService = RegistryService.instance();
 			UDDIRegistryService uddiRegistryService = UDDIRegistryService.instance();
 			UDDIRegistry uddiRegistry = uddiRegistryService.newUDDIRegistry();

 			System.out.println("Building a simple Registry model");
 			uddiRegistry.setId("my.registry");
 			uddiRegistry.setVersion("2.0");
 			uddiRegistry.setDiscoveryURL("http://some.discovery.url");
 			uddiRegistry.setPublicationURL("http://some.publication.url");
 			uddiRegistry.setDefaultLogin("hockeyfanatic");
 			Name name = RegistryFactory.eINSTANCE.createName();
 			name.setValue("My Registry");
 			uddiRegistry.getName().add(name);
 			Taxonomy taxonomyRef = registryService.newTaxonomy();
 			taxonomyRef.setRef("my.taxonomy");
 			Taxonomies t = uddiRegistry.getTaxonomies();
 			if (t == null)
 			{
 				t = UDDIRegistryFactory.eINSTANCE.createTaxonomies();
 				uddiRegistry.setTaxonomies(t);
 			}
 			EList e = t.getTaxonomy();
 			e.add(taxonomyRef);

 			File file = File.createTempFile("registry.",".xml");
 			System.out.println("Saving the Registry model to "+file.getCanonicalPath());
 			registryService.saveRegistry(file.toURL(),uddiRegistry);
 		}
 		catch (Exception exc)
 		{
 			exc.printStackTrace();
 			fail("Unexpected Throwable ["+exc.getMessage()+"]");
 		}
 		finally
 		{
 			System.out.println("FINISHED test_RegistryService_saveRegistry\n");
 		}
 	}

 	/**
 	 * Creates a new UDDI Registry model and a new Taxonomy
 	 * model, associates the latter with the former, and
 	 * drives <code>IRegistryManager.saveRegistry()</code>
 	 * to save the models and the index document to the
 	 * preferred location of the default registry manager.
 	 */
 	public void test_RegistryManager_saveRegistry()
 	{
 		System.out.println("STARTING test_RegistryManager_saveRegistry");
 		try {
 			System.out.println("Creating RegistryService and Getting RegistryManager");
 			RegistryService registryService = RegistryService.instance();
 			IRegistryManager regManager = registryService.getDefaultRegistryManager();
 			System.out.println("The location of the default index is " + regManager.getURL());

 			//build the hockey taxonomy
 			System.out.println("Building the hockey Taxonomy model");
 			Taxonomy hockeyTaxonomy = registryService.newTaxonomy();
 			hockeyTaxonomy.setId("hockey.taxonomy");
 			hockeyTaxonomy.setName("hockey Taxonomy");
 			EList list = hockeyTaxonomy.getCategory();
 			Category category1 = TaxonomyFactory.eINSTANCE.createCategory();
 			Category category4 = TaxonomyFactory.eINSTANCE.createCategory();
 			category4.setName("Pro");
 			category4.setCode("4");
 			Category category5 = TaxonomyFactory.eINSTANCE.createCategory();
 			category5.setName("AHL");
 			category5.setCode("4.1");
 			Category category6 = TaxonomyFactory.eINSTANCE.createCategory();
 			category6.setName("NHL");
 			category6.setCode("4.2");
 			category1.setName("Junior");
 			category1.setCode("1");
 			Category category2 = TaxonomyFactory.eINSTANCE.createCategory();
 			category2.setName("Midget");
 			category2.setCode("2");
 			Category category3 = TaxonomyFactory.eINSTANCE.createCategory();
 			category3.setName("Bantam");
 			category3.setCode("3");
 			category4.getCategory().add(category5);
 			category4.getCategory().add(category6);
 			list.add(category1);
 			list.add(category2);
 			list.add(category3);
 			list.add(category4);

 			//save the hockey taxonomy
 			Taxonomy hockeyTaxonomyRef = regManager.saveTaxonomy(hockeyTaxonomy);

 			//make the hockey registry
 			System.out.println("Building the hockey Registry model");
 			UDDIRegistryService uddiRegistryService = UDDIRegistryService.instance();
 			UDDIRegistry uddiRegistry = uddiRegistryService.newUDDIRegistry();
 			uddiRegistry.setId("hockey.registry");
 			uddiRegistry.setVersion("2.0");
 			uddiRegistry.setDefaultLogin("hockeyfanatic");
 			uddiRegistry.setDiscoveryURL("http://some.discovery.url");
 			uddiRegistry.setPublicationURL("http://some.publication.url");
 			Name name = RegistryFactory.eINSTANCE.createName();
 			name.setValue("Hockey Registry");
 			uddiRegistry.getName().add(name);

 			// Add the reference to the taxonomy (saved above) to the registry.
 			uddiRegistryService.addTaxonomy(uddiRegistry,hockeyTaxonomyRef);

 			/*
 			UDDITaxonomyFinder UITFinder = new UDDITaxonomyFinder();
 			regManager.addTaxonomyFinder(uddiRegistry.getClass().getName(),UITFinder);
 			*/
 			// Save the thing.
 			System.out.println("Saving the hockey Registry model");
 			regManager.saveRegistry(uddiRegistry);
 		}
 		catch (Exception exc)
 		{
 			exc.printStackTrace();
 			fail("Unexpected Throwable ["+exc.getMessage()+"]");
 		}
 		finally
 		{
 			System.out.println("FINISHED test_RegistryManager_saveRegistry\n");
 		}
 	}

 	/**
 	 * Loads the registry and taxonomy in the index created in
 	 * test_RegistryManager_saveRegistry, then asserts that the
 	 * content of the model is what we expect.
 	 */
 	public void test_RegistryManager_loadRegistry()
 	{
 		System.out.println("STARTING test_RegistryManager_loadRegistry");
 		try {
 			// Setup
 			System.out.println("Creating RegistryService and Getting RegistryManager");
 			RegistryService registryService = RegistryService.instance();
 			IRegistryManager regManager = registryService.getDefaultRegistryManager();

 			// Get the one registry URI we expect, and load the registry.
 			String[] registries = regManager.getRegistryURIs();
 			assertEquals("Unexpected number of registries "+registries.length,registries.length,1);
 			String uri = registries[0];
 			System.out.println("Loading registry " + uri);
 			Registry registry = regManager.loadRegistry(uri);
 			System.out.println("Found registry " + registry.getId());
 			assertEquals("Did not find hockey registry","hockey.registry",registry.getId());

 			// It's supposed to be a UDDI registry. Verify it and check its values.
 			assertTrue("Registry is not a UDDIRegistry",(registry instanceof UDDIRegistry));
 			UDDIRegistry uddiRegistry = (UDDIRegistry)registry;
 			assertEquals(uddiRegistry.getVersion(),"2.0");
 			assertEquals(uddiRegistry.getDefaultLogin(),"hockeyfanatic");
 			assertEquals(uddiRegistry.getDiscoveryURL(),"http://some.discovery.url");
 			assertEquals(uddiRegistry.getPublicationURL(),"http://some.publication.url");

 			// Load the taxonomies used the UDDI registry.
 			UDDIRegistryService uddiRegistryService = UDDIRegistryService.instance();
 			Taxonomy[] taxonomies = regManager.loadTaxonomies(uddiRegistryService.getTaxonomyURIs(uddiRegistry));
 			assertEquals("Unexpected number of taxonomies "+taxonomies.length,taxonomies.length,1);
 			Taxonomy taxonomy = taxonomies[0];
 			System.out.println("Found taxonomy " + taxonomy.getId());
 			Assert.assertEquals("Did not find hockey taxonomy","hockey.taxonomy",taxonomy.getId());

 			// Dump out the values (no assertions here).
 			EList cList = taxonomy.getCategory();
 			for(int i = 0;i<cList.size();i++){
 				Category category = (Category)cList.get(i);
 				System.out.println("Found category " + category.getName());
 				EList c2List = category.getCategory();
 				for(int j = 0;j<c2List.size();j++){
 					Category iCategory = (Category)c2List.get(j);
 					System.out.println("Found subcategory " + iCategory.getName());
 				}
 			}
 		}
 		catch(Exception t)
 		{
 			t.printStackTrace();
 			fail("Unexpected Throwable ["+t.getMessage()+"]");
 		}
 		finally
 		{
 			System.out.println("FINISHED test_RegistryManager_loadRegistry\n");
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2007 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.wst.ws.tests.unittest;

	import java.io.File;

	import junit.framework.Assert;
	import junit.framework.Test;
	import junit.framework.TestCase;
	import junit.framework.TestSuite;

	import org.eclipse.emf.common.util.EList;
	import org.eclipse.wst.ws.internal.model.v10.registry.Name;
	import org.eclipse.wst.ws.internal.model.v10.registry.Registry;
	import org.eclipse.wst.ws.internal.model.v10.registry.RegistryFactory;
	import org.eclipse.wst.ws.internal.model.v10.taxonomy.Category;
	import org.eclipse.wst.ws.internal.model.v10.taxonomy.Taxonomy;
	import org.eclipse.wst.ws.internal.model.v10.taxonomy.TaxonomyFactory;
	import org.eclipse.wst.ws.internal.model.v10.uddiregistry.Taxonomies;
	import org.eclipse.wst.ws.internal.model.v10.uddiregistry.UDDIRegistry;
	import org.eclipse.wst.ws.internal.model.v10.uddiregistry.UDDIRegistryFactory;
	import org.eclipse.wst.ws.internal.registry.IRegistryManager;
	import org.eclipse.wst.ws.internal.registry.RegistryService;
	import org.eclipse.wst.ws.internal.registry.UDDIRegistryService;

	public class RegistryTests extends TestCase
	{
	public static Test suite ()
	{
	return new TestSuite(RegistryTests.class);
	}

	/**
	* Creates a new Taxonomy model and passes it to
	* <code>RegistryService.saveTaxonomy()</code>
	* where the model is persisted to a platform
	* specified temporary filesystem location.
	*/
	public void test_RegistryService_saveTaxonomy ()
	{
	System.out.println("STARTING test_RegistryService_saveTaxonomy");
	try
	{
	System.out.println("Creating RegistryService and Taxonomy");
	RegistryService registryService = RegistryService.instance();
	Taxonomy taxonomy = registryService.newTaxonomy();

	System.out.println("Building a simple Taxonomy model");
	taxonomy.setId("my.taxonomy");
	taxonomy.setName("My Taxonomy");
	EList list = taxonomy.getCategory();
	Category category1 = TaxonomyFactory.eINSTANCE.createCategory();
	category1.setName("My first category");
	category1.setCode("1");
	Category category2 = TaxonomyFactory.eINSTANCE.createCategory();
	category2.setName("My second category");
	category2.setCode("2");
	Category category3 = TaxonomyFactory.eINSTANCE.createCategory();
	category3.setName("My third category");
	category3.setCode("2.1");
	category2.getCategory().add(category3);
	list.add(category1);
	list.add(category2);

	File file = File.createTempFile("taxonomy.",".xml");
	System.out.println("Saving the Taxonomy model to "+file.getCanonicalPath());
	registryService.saveTaxonomy(file.toURL(),taxonomy);
	}
	catch (Exception exc)
	{
	exc.printStackTrace();
	fail("Unexpected Throwable ["+exc.getMessage()+"]");
	}
	finally
	{
	System.out.println("FINISHED test_RegistryService_saveTaxonomy\n");
	}
	}

	/**
	* Creates a new UDDI Registry model and passes it to
	* <code>RegistryService.saveRegistry()</code>
	* where the model is persisted to a platform
	* specified temporary filesystem location.
	*/
	public void test_RegistryService_saveRegistry ()
	{
	System.out.println("STARTING test_RegistryService_saveRegistry");
	try
	{
	System.out.println("Creating RegistryService, UDDIRegistryService and Registry");
	RegistryService registryService = RegistryService.instance();
	UDDIRegistryService uddiRegistryService = UDDIRegistryService.instance();
	UDDIRegistry uddiRegistry = uddiRegistryService.newUDDIRegistry();

	System.out.println("Building a simple Registry model");
	uddiRegistry.setId("my.registry");
	uddiRegistry.setVersion("2.0");
	uddiRegistry.setDiscoveryURL("http://some.discovery.url");
	uddiRegistry.setPublicationURL("http://some.publication.url");
	uddiRegistry.setDefaultLogin("hockeyfanatic");
	Name name = RegistryFactory.eINSTANCE.createName();
	name.setValue("My Registry");
	uddiRegistry.getName().add(name);
	Taxonomy taxonomyRef = registryService.newTaxonomy();
	taxonomyRef.setRef("my.taxonomy");
	Taxonomies t = uddiRegistry.getTaxonomies();
	if (t == null)
	{
	t = UDDIRegistryFactory.eINSTANCE.createTaxonomies();
	uddiRegistry.setTaxonomies(t);
	}
	EList e = t.getTaxonomy();
	e.add(taxonomyRef);

	File file = File.createTempFile("registry.",".xml");
	System.out.println("Saving the Registry model to "+file.getCanonicalPath());
	registryService.saveRegistry(file.toURL(),uddiRegistry);
	}
	catch (Exception exc)
	{
	exc.printStackTrace();
	fail("Unexpected Throwable ["+exc.getMessage()+"]");
	}
	finally
	{
	System.out.println("FINISHED test_RegistryService_saveRegistry\n");
	}
	}

	/**
	* Creates a new UDDI Registry model and a new Taxonomy
	* model, associates the latter with the former, and
	* drives <code>IRegistryManager.saveRegistry()</code>
	* to save the models and the index document to the
	* preferred location of the default registry manager.
	*/
	public void test_RegistryManager_saveRegistry()
	{
	System.out.println("STARTING test_RegistryManager_saveRegistry");
	try {
	System.out.println("Creating RegistryService and Getting RegistryManager");
	RegistryService registryService = RegistryService.instance();
	IRegistryManager regManager = registryService.getDefaultRegistryManager();
	System.out.println("The location of the default index is " + regManager.getURL());

	//build the hockey taxonomy
	System.out.println("Building the hockey Taxonomy model");
	Taxonomy hockeyTaxonomy = registryService.newTaxonomy();
	hockeyTaxonomy.setId("hockey.taxonomy");
	hockeyTaxonomy.setName("hockey Taxonomy");
	EList list = hockeyTaxonomy.getCategory();
	Category category1 = TaxonomyFactory.eINSTANCE.createCategory();
	Category category4 = TaxonomyFactory.eINSTANCE.createCategory();
	category4.setName("Pro");
	category4.setCode("4");
	Category category5 = TaxonomyFactory.eINSTANCE.createCategory();
	category5.setName("AHL");
	category5.setCode("4.1");
	Category category6 = TaxonomyFactory.eINSTANCE.createCategory();
	category6.setName("NHL");
	category6.setCode("4.2");
	category1.setName("Junior");
	category1.setCode("1");
	Category category2 = TaxonomyFactory.eINSTANCE.createCategory();
	category2.setName("Midget");
	category2.setCode("2");
	Category category3 = TaxonomyFactory.eINSTANCE.createCategory();
	category3.setName("Bantam");
	category3.setCode("3");
	category4.getCategory().add(category5);
	category4.getCategory().add(category6);
	list.add(category1);
	list.add(category2);
	list.add(category3);
	list.add(category4);

	//save the hockey taxonomy
	Taxonomy hockeyTaxonomyRef = regManager.saveTaxonomy(hockeyTaxonomy);

	//make the hockey registry
	System.out.println("Building the hockey Registry model");
	UDDIRegistryService uddiRegistryService = UDDIRegistryService.instance();
	UDDIRegistry uddiRegistry = uddiRegistryService.newUDDIRegistry();
	uddiRegistry.setId("hockey.registry");
	uddiRegistry.setVersion("2.0");
	uddiRegistry.setDefaultLogin("hockeyfanatic");
	uddiRegistry.setDiscoveryURL("http://some.discovery.url");
	uddiRegistry.setPublicationURL("http://some.publication.url");
	Name name = RegistryFactory.eINSTANCE.createName();
	name.setValue("Hockey Registry");
	uddiRegistry.getName().add(name);

	// Add the reference to the taxonomy (saved above) to the registry.
	uddiRegistryService.addTaxonomy(uddiRegistry,hockeyTaxonomyRef);

	/*
	UDDITaxonomyFinder UITFinder = new UDDITaxonomyFinder();
	regManager.addTaxonomyFinder(uddiRegistry.getClass().getName(),UITFinder);
	*/
	// Save the thing.
	System.out.println("Saving the hockey Registry model");
	regManager.saveRegistry(uddiRegistry);
	}
	catch (Exception exc)
	{
	exc.printStackTrace();
	fail("Unexpected Throwable ["+exc.getMessage()+"]");
	}
	finally
	{
	System.out.println("FINISHED test_RegistryManager_saveRegistry\n");
	}
	}

	/**
	* Loads the registry and taxonomy in the index created in
	* test_RegistryManager_saveRegistry, then asserts that the
	* content of the model is what we expect.
	*/
	public void test_RegistryManager_loadRegistry()
	{
	System.out.println("STARTING test_RegistryManager_loadRegistry");
	try {
	// Setup
	System.out.println("Creating RegistryService and Getting RegistryManager");
	RegistryService registryService = RegistryService.instance();
	IRegistryManager regManager = registryService.getDefaultRegistryManager();

	// Get the one registry URI we expect, and load the registry.
	String[] registries = regManager.getRegistryURIs();
	assertEquals("Unexpected number of registries "+registries.length,registries.length,1);
	String uri = registries[0];
	System.out.println("Loading registry " + uri);
	Registry registry = regManager.loadRegistry(uri);
	System.out.println("Found registry " + registry.getId());
	assertEquals("Did not find hockey registry","hockey.registry",registry.getId());

	// It's supposed to be a UDDI registry. Verify it and check its values.
	assertTrue("Registry is not a UDDIRegistry",(registry instanceof UDDIRegistry));
	UDDIRegistry uddiRegistry = (UDDIRegistry)registry;
	assertEquals(uddiRegistry.getVersion(),"2.0");
	assertEquals(uddiRegistry.getDefaultLogin(),"hockeyfanatic");
	assertEquals(uddiRegistry.getDiscoveryURL(),"http://some.discovery.url");
	assertEquals(uddiRegistry.getPublicationURL(),"http://some.publication.url");

	// Load the taxonomies used the UDDI registry.
	UDDIRegistryService uddiRegistryService = UDDIRegistryService.instance();
	Taxonomy[] taxonomies = regManager.loadTaxonomies(uddiRegistryService.getTaxonomyURIs(uddiRegistry));
	assertEquals("Unexpected number of taxonomies "+taxonomies.length,taxonomies.length,1);
	Taxonomy taxonomy = taxonomies[0];
	System.out.println("Found taxonomy " + taxonomy.getId());
	Assert.assertEquals("Did not find hockey taxonomy","hockey.taxonomy",taxonomy.getId());

	// Dump out the values (no assertions here).
	EList cList = taxonomy.getCategory();
	for(int i = 0;i<cList.size();i++){
	Category category = (Category)cList.get(i);
	System.out.println("Found category " + category.getName());
	EList c2List = category.getCategory();
	for(int j = 0;j<c2List.size();j++){
	Category iCategory = (Category)c2List.get(j);
	System.out.println("Found subcategory " + iCategory.getName());
	}
	}
	}
	catch(Exception t)
	{
	t.printStackTrace();
	fail("Unexpected Throwable ["+t.getMessage()+"]");
	}
	finally
	{
	System.out.println("FINISHED test_RegistryManager_loadRegistry\n");
	}
	}
	}