Google App Engine: test d'unité d'accès simultané à memcache

Question

Pouvez-vous me montrer un moyen de simuler l'accès simultané à memcache sur Google App Engine? J'essaye avec LocalServiceTestHelpers et les discussions mais n'ai pas de chance. Chaque fois que je tente d'accéder Memcache dans un fil, alors je reçois cette erreur:

ApiProxy$CallNotFoundException: The API package 'memcache' or call 'Increment()' was not found 

Je suppose que la bibliothèque de tests de GAE SDK a essayé d'imiter l'environnement réel et donc la configuration de l'environnement pour un seul fil (la thread qui exécute le test) qui ne peut pas être vu par un autre thread.

Voici un morceau de code qui peut reproduire le problème

package org.seamoo.cache.memcacheImpl; 

import org.testng.Assert; 
import org.testng.annotations.AfterMethod; 
import org.testng.annotations.BeforeMethod; 
import org.testng.annotations.Test; 

import com.google.appengine.api.memcache.MemcacheService; 
import com.google.appengine.api.memcache.MemcacheServiceFactory; 
import com.google.appengine.tools.development.testing.LocalMemcacheServiceTestConfig; 
import com.google.appengine.tools.development.testing.LocalServiceTestHelper; 

public class MemcacheTest { 
LocalServiceTestHelper helper; 

public MemcacheTest() { 
    LocalMemcacheServiceTestConfig memcacheConfig = new LocalMemcacheServiceTestConfig(); 
    helper = new LocalServiceTestHelper(memcacheConfig); 
} 

/** 
    * 
    */ 
@BeforeMethod 
public void setUp() { 
    helper.setUp(); 
} 

/** 
    * @see LocalServiceTest#tearDown() 
    */ 
@AfterMethod 
public void tearDown() { 
    helper.tearDown(); 
} 

@Test 
public void memcacheConcurrentAccess() throws InterruptedException { 
    final MemcacheService service = MemcacheServiceFactory.getMemcacheService(); 
    Runnable runner = new Runnable() { 

    @Override 
    public void run() { 
    // TODO Auto-generated method stub 
    service.increment("test-key", 1L, 1L); 
    try { 
    Thread.sleep(200L); 
    } catch (InterruptedException e) { 
    // TODO Auto-generated catch block 
    e.printStackTrace(); 
    } 
    service.increment("test-key", 1L, 1L); 
    } 
    }; 

    Thread t1 = new Thread(runner); 
    Thread t2 = new Thread(runner); 
    t1.start(); 
    t2.start(); 
    while (t1.isAlive()) { 
    Thread.sleep(100L); 
    } 
    Assert.assertEquals((Long) (service.get("test-key")), new Long(4L)); 
} 
} 

Answer 1

Essayez-vous de tester votre application ou l'implémentation memcache d'App Engine? La sémantique de memcache sous les lectures et les écritures simultanées est bien comprise - vous feriez mieux de simplement simuler les conditions qui peuvent survenir afin de vérifier que votre application les gère correctement.

Answer 2

I guess that the testing library of GAE SDK tried to mimic the real environment and thus setup the environment for only one thread (the thread that running the test) which cannot be seen by other thread.

Cette estimation est à peu près correct: depuis GAE exécute lui-même jamais plusieurs threads au sein d'un processus, donc de la même ni ne le SDK - il n'est donc pas clair pour moi pourquoi vous voulez tester un accès multithread qui ne peut tout simplement pas se produire dans GAE.

Answer 3

GAE ne prend pas en charge les threads utilisateur. Je pense que vous essayez de trop compliquer. L'une des façons de tester cela consiste à créer un client Thread externe et à générer autant de threads que vous le souhaitez pour accéder à GAE à distance. Si cela fonctionne sur votre boîte locale, pointez là.

Answer 4

Le problème est de savoir comment les fils sont mis en place, et peuvent être résolus à l'aide du ThreadManager fourni dans les SDKs:

private final LocalServiceTestHelper helper = 
     new LocalServiceTestHelper(new LocalDatastoreServiceTestConfig()); 

@Before 
public void setUp() throws Exception { 
    helper.setUp(); 
} 

@After 
public void tearDown() throws Exception { 
    helper.tearDown(); 
} 

AtomicInteger threadsRemaining = new AtomicInteger(NUM_USERS); 
AtomicInteger numFailingThreads = new AtomicInteger(0); 

@Test 
public void testManyUsers() throws Exception { 


    ArrayList<TestUser> testUsers = new ArrayList<TestUser>(); 

    // Create something to test in parallel (in this case a "user") 
    for (int i = 0; i < NUM_USERS; ++i) { 
     testUsers.add(new TestUser()); 
    } 

    // Fork off a thread for each user 
    runInParallel(testUsers); 

    // Wait for threads to complete. 
    while (threadsRemaining.intValue() != 0) { 
     Thread.sleep(10); // TODO: Clean up with callbacks or whatever. 
    } 

    assertEquals(numFailingThreads.intValue(), 0); 
} 

private void runInParallel(final ArrayList<TestUser> testUsers) { 


    for (final TestUser u : testUsers) { 

     Runnable myTask = new Runnable() { 

      @Override 
      public void run() { 
       try { 

        // The user tries to kill my server 

       } catch (Exception e) { 

        // The user triggered badness in my server 

        e.printStackTrace(); 
        numFailingThreads.incrementAndGet(); 
       } 
       threadsRemaining.decrementAndGet(); 
      } 
     }; 

     ThreadFactory threadFactory = ThreadManager.currentRequestThreadFactory(); 

     Thread t = threadFactory.newThread(myTask); 

     t.start(); 
    } 


}