stack/corepersistence/collection/src/test/java/org/apache/usergrid/persistence/collection/serialization/impl/MvccEntitySerializationStrategyV2Test.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.apache.usergrid.persistence.collection.serialization.impl;


import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import org.apache.usergrid.persistence.model.util.EntityUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import org.apache.usergrid.persistence.collection.EntitySet;
import org.apache.usergrid.persistence.collection.MvccEntity;
import org.apache.usergrid.persistence.collection.exception.EntityTooLargeException;
import org.apache.usergrid.persistence.collection.mvcc.entity.impl.MvccEntityImpl;
import org.apache.usergrid.persistence.collection.serialization.SerializationFig;
import org.apache.usergrid.persistence.collection.util.EntityHelper;
import org.apache.usergrid.persistence.core.CassandraFig;
import org.apache.usergrid.persistence.core.guicyfig.SetConfigTestBypass;
import org.apache.usergrid.persistence.core.scope.ApplicationScope;
import org.apache.usergrid.persistence.core.scope.ApplicationScopeImpl;
import org.apache.usergrid.persistence.core.util.ValidationUtils;
import org.apache.usergrid.persistence.model.entity.Entity;
import org.apache.usergrid.persistence.model.entity.Id;
import org.apache.usergrid.persistence.model.entity.SimpleId;
import org.apache.usergrid.persistence.model.util.UUIDGenerator;

import com.google.inject.Inject;
import com.netflix.astyanax.connectionpool.exceptions.ConnectionException;

import static org.junit.Assert.assertNotNull;


public abstract class MvccEntitySerializationStrategyV2Test extends MvccEntitySerializationStrategyImplTest {


    @Inject
    protected SerializationFig serializationFig;

    @Inject
    protected CassandraFig cassandraFig;


    private int setMaxEntitySize;


    @Before
    public void setUp() {


        setMaxEntitySize = serializationFig.getMaxEntitySize();
    }


    @After
    public void tearDown() {
        SetConfigTestBypass.setValueByPass( serializationFig, "getMaxEntitySize", setMaxEntitySize + "" );
    }


    /**
     * Tests an entity with more than  65535 bytes worth of data is successfully stored and retrieved
     */
    @Test
    public void largeEntityWriteRead() throws ConnectionException {
        final int setSize = 65535 * 2;


        //this is the size it works out to be when serialized, we want to allow this size

        SetConfigTestBypass.setValueByPass( serializationFig, "getMaxEntitySize", 65535 * 10 + "" );
        final Entity entity = EntityHelper.generateEntity( setSize );

        //now we have one massive, entity, save it and retrieve it.
        final Id applicationId = new SimpleId( "application" );

        ApplicationScope context = new ApplicationScopeImpl( applicationId );


        final Id id = entity.getId();
        ValidationUtils.verifyIdentity( id );
        final UUID version = UUIDGenerator.newTimeUUID();
        EntityUtils.setVersion(entity,version);

        final MvccEntity.Status status = MvccEntity.Status.COMPLETE;

        final MvccEntity mvccEntity = new MvccEntityImpl( id, version, status, entity );


        getMvccEntitySerializationStrategy().write( context, mvccEntity ).execute();

        //now load it
        final MvccEntity loadedEntity =
                getMvccEntitySerializationStrategy().load( context, id ).get();



        assertLargeEntity( mvccEntity, loadedEntity );


        MvccEntity returned =
                serializationStrategy.load( context, Collections.singleton( id ), version ).getEntity( id );

        assertLargeEntity( mvccEntity, returned );
    }


    /**
     * Tests an entity with more than  65535 bytes worth of data is successfully stored and retrieved
     */
    @Test( expected = EntityTooLargeException.class )
    public void entityLargerThanAllowedWrite() throws ConnectionException {
        final int setSize = serializationFig.getMaxEntitySize() + 1;

        final Entity entity = EntityHelper.generateEntity( setSize );

        //now we have one massive, entity, save it and retrieve it.
        final Id applicationId = new SimpleId( "application" );

              ApplicationScope context = new ApplicationScopeImpl( applicationId );


        final Id id = entity.getId();
        ValidationUtils.verifyIdentity( id );
        final UUID version = UUIDGenerator.newTimeUUID();
        final MvccEntity.Status status = MvccEntity.Status.COMPLETE;

        final MvccEntity mvccEntity = new MvccEntityImpl( id, version, status, entity );


        getMvccEntitySerializationStrategy().write( context, mvccEntity ).execute();
    }


    /**
     * Tests an entity with more than  65535 bytes worth of data is successfully stored and retrieved
     */
    @Test
    public void largeEntityReadWrite() throws ConnectionException {

        //this is the size it works out to be when serialized, we want to allow this size

        //extreme edge case, we can only get 2 entities per call
        final int thriftBuffer = cassandraFig.getThriftBufferSize();



        //we use 20, using 2 causes cassandra to OOM. We don't have a large enough instance running locally

        final int maxEntitySize = ( int ) ( ( thriftBuffer * .9 ) / 20  );


        SetConfigTestBypass.setValueByPass( serializationFig, "getMaxEntitySize", maxEntitySize + "" );


        final int size = 100;

        final HashMap<Id, MvccEntity> entities = new HashMap<>( size );

        ApplicationScope context =
                new ApplicationScopeImpl( new SimpleId( "organization" ));


        for ( int i = 0; i < size; i++ ) {
            final Entity entity = EntityHelper.generateEntity( ( int ) (maxEntitySize*.4) );

            //now we have one massive, entity, save it and retrieve it.

            final Id id = entity.getId();
            ValidationUtils.verifyIdentity( id );
            final UUID version = UUIDGenerator.newTimeUUID();
            EntityUtils.setVersion(entity,version);

            final MvccEntity.Status status = MvccEntity.Status.COMPLETE;

            final MvccEntity mvccEntity = new MvccEntityImpl( id, version, status, entity );


            getMvccEntitySerializationStrategy().write( context, mvccEntity ).execute();

            entities.put( id, mvccEntity );
        }


        //now load it, we ask for 100 and we only are allowed 2 per trip due to our max size constraints.  Should all
        //still load (note that users should not be encouraged to use this strategy, it's a bad idea!)
        final EntitySet loaded =
                getMvccEntitySerializationStrategy().load( context, entities.keySet(), UUIDGenerator.newTimeUUID() );

        assertNotNull( "Entity set was loaded", loaded );


        for ( Map.Entry<Id, MvccEntity> entry : entities.entrySet() ) {

            final MvccEntity returned = loaded.getEntity( entry.getKey() );

            assertLargeEntity( entry.getValue(), returned );
        }
    }




    protected void assertLargeEntity( final MvccEntity expected, final MvccEntity returned ) {

        org.junit.Assert.assertEquals( "The loaded entity should match the stored entity", expected, returned );

        EntityHelper.verifyDeepEquals( expected.getEntity().get(), returned.getEntity().get() );
    }
}