plugins/org.eclipse.wst.sse.sieditor.test/api/org/eclipse/wst/sse/sieditor/test/ui/v2/dt/nodes/impl/ImportedSchemaNodeTest.java

/*******************************************************************************
 * Copyright (c) 2010 SAP AG.
 * 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:
 *    Emil Simeonov - initial API and implementation.
 *    Dimitar Donchev - initial API and implementation.
 *    Dimitar Tenev - initial API and implementation.
 *    Nevena Manova - initial API and implementation.
 *    Georgi Konstantinov - initial API and implementation.
 *******************************************************************************/
package org.eclipse.wst.sse.sieditor.test.ui.v2.dt.nodes.impl;

import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.Collection;

import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.wst.sse.sieditor.ui.v2.UIConstants;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.IDataTypesTreeNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.impl.ImportedSchemaNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.impl.ImportedTypesNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.impl.SimpleTypeNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.impl.StructureTypeNode;
import org.eclipse.wst.sse.sieditor.ui.v2.factory.TreeNodeMapper;
import org.eclipse.wst.sse.sieditor.ui.v2.nodes.ITreeNode;
import org.eclipse.wst.sse.sieditor.test.util.EasymockModelUtils;
import org.eclipse.xsd.XSDSchema;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import org.eclipse.wst.sse.sieditor.model.api.IModelObject;
import org.eclipse.wst.sse.sieditor.model.api.IModelRoot;
import org.eclipse.wst.sse.sieditor.model.xsd.api.ISchema;
import org.eclipse.wst.sse.sieditor.model.xsd.api.ISimpleType;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IStructureType;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IType;
import org.eclipse.wst.sse.sieditor.ui.Activator;

public class ImportedSchemaNodeTest {

    private static final String LOCATION = "location";

    private static final String NAMESPACE = "http://namespace.com/schema"; //$NON-NLS-1$

    private ISchema schema;

    private ImportedSchemaNode node;

    @Before
    public void setUp() throws Exception {
        schema = EasymockModelUtils.createISchemaMockFromSameModel();
        replay(schema);

        final ImportedTypesNode importedTypesNode = new ImportedTypesNode(null, new TreeNodeMapper());
        node = new ImportedSchemaNode(schema, importedTypesNode, new TreeNodeMapper());

        reset(schema);
    }

    @After
    public void tearDown() throws Exception {
        schema = null;
        node = null;
    }

    @Test
    public void testIsReadOnly() {
        replay(schema);
        assertTrue(node.isReadOnly());
    }

    @Test
    public void testGetDisplayNameWithNullMainSchemaLocation() {
        // see ImportedSchemaNode class for mainSchemaLocation and
        // importedSchemaLocation
        final IModelRoot modelRoot = createMock(IModelRoot.class);
        expect(modelRoot.getModelObject()).andReturn(schema).anyTimes();
        replay(modelRoot);

        final XSDSchema xsdSchema = createMock(XSDSchema.class);
        replay(xsdSchema);

        expect(schema.getNamespace()).andReturn(NAMESPACE).atLeastOnce();
        expect(schema.getLocation()).andReturn(LOCATION);
        expect(schema.getModelRoot()).andReturn(modelRoot).anyTimes();
        expect(schema.getComponent()).andReturn(xsdSchema).anyTimes();
        replay(schema);

        final ImportedSchemaNode node = new ImportedSchemaNode(schema, createMock(ITreeNode.class), new TreeNodeMapper());

        assertEquals(NAMESPACE + UIConstants.SPACE + UIConstants.OPEN_BRACKET + LOCATION + UIConstants.CLOSE_BRACKET, node
                .getDisplayName());
        verify(schema);

        reset(schema);
        expect(schema.getNamespace()).andReturn(NAMESPACE).atLeastOnce();
        expect(schema.getLocation()).andReturn(null);
        expect(schema.getModelRoot()).andReturn(modelRoot).anyTimes();
        expect(schema.getComponent()).andReturn(xsdSchema).anyTimes();
        replay(schema);

        assertEquals(NAMESPACE + UIConstants.SPACE + UIConstants.OPEN_BRACKET + UIConstants.CLOSE_BRACKET, node.getDisplayName());
        verify(schema);
    }

    @Test
    public void testGetDisplayNameWithNullImportedSchemaLocation() {
        // see ImportedSchemaNode class for mainSchemaLocation and
        // importedSchemaLocation

        final IModelRoot modelRoot = createMock(IModelRoot.class);
        expect(modelRoot.getModelObject()).andReturn(schema).anyTimes();
        replay(modelRoot);

        final XSDSchema xsdSchema = createMock(XSDSchema.class);
        replay(xsdSchema);

        expect(schema.getNamespace()).andReturn(NAMESPACE).atLeastOnce();
        expect(schema.getLocation()).andReturn(null);
        expect(schema.getModelRoot()).andReturn(modelRoot).anyTimes();
        expect(schema.getComponent()).andReturn(xsdSchema).anyTimes();
        replay(schema);

        final ImportedSchemaNode node = new ImportedSchemaNode(schema, createMock(ITreeNode.class), new TreeNodeMapper()); //$NON-NLS-1$

        assertEquals(NAMESPACE + UIConstants.SPACE + UIConstants.OPEN_BRACKET + UIConstants.CLOSE_BRACKET, node.getDisplayName());
        verify(schema);
    }

    @Test
    public void testGetDisplayName1() {
        testDisplayText("file:///c:/workspace/project1/src/wsdls/SalesOrder.wsdl", //$NON-NLS-1$
                "file:///c:/workspace/project1/src/wsdls/SalesOrder.wsdl", //$NON-NLS-1$ 
                "file:///c:/workspace/project1/src/wsdls/SalesOrder.wsdl"); //$NON-NLS-1$
    }

    private void testDisplayText(final String mainSchemaLocation, final String importedSchemaLocation,
            final String expectedDisplayName) {
        // see ImportedSchemaNode class for mainSchemaLocation and
        // importedSchemaLocation
        final IModelRoot modelRoot = createMock(IModelRoot.class);
        expect(modelRoot.getModelObject()).andReturn(schema).anyTimes();
        replay(modelRoot);

        final XSDSchema xsdSchema = createMock(XSDSchema.class);
        replay(xsdSchema);

        expect(schema.getNamespace()).andReturn(NAMESPACE).atLeastOnce();
        expect(schema.getLocation()).andReturn(importedSchemaLocation);
        expect(schema.getModelRoot()).andReturn(modelRoot).anyTimes();
        expect(schema.getComponent()).andReturn(xsdSchema).anyTimes();
        replay(schema);

        final ImportedSchemaNode node = new ImportedSchemaNode(schema, createMock(ITreeNode.class), new TreeNodeMapper());

        assertEquals(NAMESPACE + UIConstants.SPACE + UIConstants.OPEN_BRACKET + expectedDisplayName + UIConstants.CLOSE_BRACKET,
                node.getDisplayName());
        verify(schema);
    }

    @Test
    public void testGetImage() {
        replay(schema);
        final Display display = Display.getDefault();
        final Image namespaceImage = new Image(display, 10, 10);
        final ImportedTypesNode importedTypesNode = new ImportedTypesNode(null, new TreeNodeMapper());
        final ImportedSchemaNode node = new ImportedSchemaNode(schema, importedTypesNode, new TreeNodeMapper()) {
            @Override
            protected ImageRegistry getImageRegistry() {
                final ImageRegistry registry = new ImageRegistry(display);
                registry.put(Activator.NODE_NAMESPACE_GRAY, namespaceImage);
                return registry;
            }
        };
        assertEquals(namespaceImage, node.getImage());
    }

    @Test
    public void testGetChildren() {
        expect(schema.getAllContainedTypes()).andReturn(new ArrayList<IType>());
        replay(schema);
        assertEquals(0, node.getChildren().length);

        class TestImportedSchemaNode extends ImportedSchemaNode {

            public int createSimpleTypeInvoked = 0;

            public int createStructureTypeInvoked = 0;

            public TestImportedSchemaNode(final IModelObject element, final ITreeNode parent, final TreeNodeMapper nodeMapper) {
                super(element, parent, nodeMapper);
            }

            public int getCreateSimpleTypeInvoked() {
                return createSimpleTypeInvoked;
            }

            public int getCreateStructureTypeInvoked() {
                return createStructureTypeInvoked;
            }

            @Override
            protected IDataTypesTreeNode createStructureTypeNode(final IType type, final TreeNodeMapper nodeMapper,
                    final ITreeNode parentNode) {
                createStructureTypeInvoked++;
                return new StructureTypeNode(type, this, nodeMapper);
            }

            @Override
            protected IDataTypesTreeNode createSimpleTypeNode(final IType type, final ITreeNode parentNode) {
                createSimpleTypeInvoked++;
                return new SimpleTypeNode(type, this);
            }
        }
        ;
        final ImportedTypesNode importedTypesNode = new ImportedTypesNode(null, new TreeNodeMapper());
        final TestImportedSchemaNode testNode = new TestImportedSchemaNode(schema, importedTypesNode, new TreeNodeMapper());

        final Collection<IType> types = new ArrayList<IType>();
        final ISimpleType simpleType = EasymockModelUtils.createISimpleTypeMockFromSameModel();
        types.add(simpleType);
        final IStructureType structureType = EasymockModelUtils.createIStructureTypeMockFromSameModel();
        types.add(structureType);
        replay(simpleType, structureType);

        reset(schema);
        expect(schema.getAllContainedTypes()).andReturn(types).once();
        replay(schema);

        assertEquals(2, testNode.getChildren().length);
        verify(schema);
        assertEquals(1, testNode.getCreateSimpleTypeInvoked());
        assertEquals(1, testNode.getCreateStructureTypeInvoked());

        reset(schema);
        expect(schema.getAllContainedTypes()).andReturn(types).atLeastOnce();
        replay(schema);

        assertEquals(2, testNode.getChildren().length);
        verify(schema);
        assertEquals(1, testNode.getCreateSimpleTypeInvoked());
        assertEquals(1, testNode.getCreateStructureTypeInvoked());
    }

}