Package org.auraframework.impl.system

Source Code of org.auraframework.impl.system.DefinitionImplUnitTest

/*
* Copyright (C) 2013 salesforce.com, inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*         http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.auraframework.impl.system;

import java.util.Map;

import org.auraframework.Aura;
import org.auraframework.def.DefDescriptor;
import org.auraframework.def.Definition;
import org.auraframework.def.Definition.Visibility;
import org.auraframework.def.DefinitionAccess;
import org.auraframework.impl.DefinitionAccessImpl;
import org.auraframework.impl.system.DefinitionImpl.RefBuilderImpl;
import org.auraframework.system.AuraContext;
import org.auraframework.system.AuraContext.Authentication;
import org.auraframework.system.AuraContext.Format;
import org.auraframework.system.AuraContext.Mode;
import org.auraframework.system.Location;
import org.auraframework.system.SubDefDescriptor;
import org.auraframework.test.UnitTestCase;
import org.auraframework.throwable.quickfix.InvalidDefinitionException;
import org.auraframework.util.text.Hash;
import org.mockito.Mock;
import org.mockito.Mockito;

import com.google.common.collect.ImmutableMap;

public abstract class DefinitionImplUnitTest<I extends DefinitionImpl<D>, D extends Definition, R extends Definition, B extends RefBuilderImpl<D, R>>
        extends UnitTestCase {

    protected String qualifiedDescriptorName;
    @Mock
    protected DefDescriptor<D> descriptor;
    @Mock
    protected Location location;
    protected Map<SubDefDescriptor<?, D>, Definition> subDefs;
    protected String description;
    protected Visibility visibility = Visibility.PUBLIC;
    protected DefinitionAccess access = null;
    @Mock
    protected Hash sourceHash;
    protected String ownHash;

    protected AuraContext testAuraContext;

    public DefinitionImplUnitTest(String name) {
        super(name);
    }

    public void testGetDescription() throws Exception {
        this.description = "this is a test Definition";
        String actual = buildDefinition().getDescription();
        assertEquals(this.description, actual);
    }

    public void testGetDescriptor() throws Exception {
        Object actual = buildDefinition().getDescriptor();
        assertEquals(this.descriptor, actual);
    }

    public void testGetLocation() throws Exception {
        Location actual = buildDefinition().getLocation();
        assertEquals(this.location, actual);
    }

    public void testGetName() throws Exception {
        String actual = buildDefinition().getName();
        assertEquals(this.qualifiedDescriptorName, actual);
    }

    public void testGetNameNullDescriptor() throws Exception {
        this.descriptor = null;
        R instance = buildDefinition();
        String expected = instance.getClass().getName();
        String actual = buildDefinition().getName();
        assertEquals(expected, actual);
    }

    public void testGetOwnHashWithSourceHash() throws Exception {
        Mockito.doReturn("myhash").when(this.sourceHash).toString();
        Mockito.doReturn(true).when(this.sourceHash).isSet();
        String actual = buildDefinition().getOwnHash();
        assertEquals("myhash", actual);
    }

    public void testGetOwnHashWithOwnHashAndNoSourceHash() throws Exception {
        this.sourceHash = null;
        this.ownHash = "ownhash";
        String actual = buildDefinition().getOwnHash();
        assertEquals(this.ownHash, actual);
    }

    public void testGetSubDefinition() throws Exception {
        @SuppressWarnings("unchecked")
        SubDefDescriptor<?, D> subdesc = Mockito.mock(SubDefDescriptor.class);
        Definition def = Mockito.mock(Definition.class);
        this.subDefs = ImmutableMap.<SubDefDescriptor<?, D>, Definition> of(subdesc, def);
        Object actual = buildDefinition().getSubDefinition(subdesc);
        assertEquals(def, actual);
    }

    public void testGetSubDefinitionNull() throws Exception {
        this.subDefs = ImmutableMap.of();
        Definition actual = buildDefinition().getSubDefinition(null);
        assertNull(actual);
    }

    public void testGetSubDefinitionWithoutSubDefinitions() throws Exception {
        SubDefDescriptor<?, ?> subdesc = Mockito.mock(SubDefDescriptor.class);
        this.subDefs = null;
        Object actual = buildDefinition().getSubDefinition(subdesc);
        assertNull(actual);
    }

    public void testGetSubDefinitionNotFound() throws Exception {
        SubDefDescriptor<?, ?> subdesc = Mockito.mock(SubDefDescriptor.class);
        this.subDefs = ImmutableMap.of();
        Object actual = buildDefinition().getSubDefinition(subdesc);
        assertNull(actual);
    }

    public void testGetVisibilityNull() throws Exception {
        this.visibility = null;
        Visibility actual = buildDefinition().getVisibility();
        assertEquals(Visibility.PUBLIC, actual);
    }

    public void testGetVisibilityNotNull() throws Exception {
        this.visibility = Visibility.PRIVATE;
        Visibility actual = buildDefinition().getVisibility();
        assertEquals(visibility, actual);
    }
   
    public void testAccessGlobal() throws Exception {
      this.access = new DefinitionAccessImpl(null, "global");
      DefinitionAccess actual = buildDefinition().getAccess();
      assertTrue(actual.isGlobal());
    }

    public void testAccessGlobalDynamic() throws Exception {
      this.access = new DefinitionAccessImpl(null, "org.auraframework.test.TestAccessMethods.allowGlobal");
      DefinitionAccess actual = buildDefinition().getAccess();
      assertTrue(actual.isGlobal());
    }
   
    public void testAccessDefault() throws Exception {
      this.access = DefinitionAccessImpl.defaultAccess(null);
      DefinitionAccess actual = buildDefinition().getAccess();
      assertTrue(actual.isPublic());
    }
   

   public void testIsValid() throws Exception {
        boolean actual = buildDefinition().isValid();
        assertFalse(actual);
    }

    public void testMarkValid() throws Exception {
        R def = buildDefinition();
        def.markValid();
        boolean actual = def.isValid();
        assertTrue(actual);
    }

    public void testValidateDefinition() throws Exception {
        buildDefinition().validateDefinition();
    }

    public void testValidateDefinitionNullDescriptor() throws Exception {
        this.descriptor = null;
        try {
            buildDefinition().validateDefinition();
            fail("Expected an exception for null descriptor");
        } catch (Exception e) {
            assertExceptionMessage(e, InvalidDefinitionException.class, "No descriptor");
        }
    }

    public void testValidateDefinitionInvalidVisibility() throws Exception {
        this.visibility = Visibility.INVALID;
        try {
            buildDefinition().validateDefinition();
            fail("Expected an exception for Visibility.INVALID");
        } catch (Exception e) {
            assertExceptionMessage(e, InvalidDefinitionException.class, "Invalid visibility value");
        }
    }

    // used to setup references to be validated by subclasses
    public void testValidateReferences() throws Exception {
        if (testAuraContext != null) {
            Aura.getContextService().endContext();
        }
       
        testAuraContext = Aura.getContextService().startContext(Mode.PROD, Format.JS, Authentication.AUTHENTICATED);
     
        setupValidateReferences();
        buildDefinition().validateReferences();
    }

    @Override
    public void tearDown() throws Exception {
        if (testAuraContext != null) {
            Aura.getContextService().endContext();
        }
    }

    protected void setupValidateReferences() throws Exception {
    }

    /**
     * Get a Builder instance to use for building test instances
     */
    protected abstract B getBuilder();

    /**
     * Get a DefinitionImpl instance to test
     */
    protected R buildDefinition() throws Exception {
        return buildDefinition(getBuilder());
    }

    protected R buildDefinition(B builder) throws Exception {
        if (this.qualifiedDescriptorName != null && this.descriptor != null) {
            Mockito.doReturn(this.qualifiedDescriptorName).when(this.descriptor).getName();
        }
        builder.setDescriptor(this.descriptor);
        builder.setLocation(this.location);
        builder.subDefs = this.subDefs;
        builder.setDescription(this.description);
        builder.setVisibility(this.visibility);
        builder.hash = this.sourceHash;
        builder.ownHash = this.ownHash;
        builder.setAccess(this.access);
        return builder.build();
    }
}
TOP

Related Classes of org.auraframework.impl.system.DefinitionImplUnitTest

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.