accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From e..@apache.org
Subject svn commit: r1437567 - in /accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy: ./ SimpleTest.java TestProxyInstanceOperations.java TestProxyReadWrite.java TestProxySecurityOperations.java TestProxyTableOperations.java
Date Wed, 23 Jan 2013 16:57:00 GMT
Author: ecn
Date: Wed Jan 23 16:57:00 2013
New Revision: 1437567

URL: http://svn.apache.org/viewvc?rev=1437567&view=rev
Log:
ACCUMULO-983 moved proxy tests into proxy package

Added:
    accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/
    accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/SimpleTest.java   (with props)
    accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyInstanceOperations.java   (with props)
    accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyReadWrite.java   (with props)
    accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxySecurityOperations.java   (with props)
    accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyTableOperations.java   (with props)

Added: accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/SimpleTest.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/SimpleTest.java?rev=1437567&view=auto
==============================================================================
--- accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/SimpleTest.java (added)
+++ accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/SimpleTest.java Wed Jan 23 16:57:00 2013
@@ -0,0 +1,303 @@
+package org.apache.accumulo.proxy;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Random;
+import java.util.Set;
+
+import org.apache.accumulo.core.iterators.DevNull;
+import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
+import org.apache.accumulo.core.util.UtilWaitThread;
+import org.apache.accumulo.proxy.thrift.AccumuloProxy.Client;
+import org.apache.accumulo.proxy.thrift.PActiveCompaction;
+import org.apache.accumulo.proxy.thrift.PActiveScan;
+import org.apache.accumulo.proxy.thrift.PColumnUpdate;
+import org.apache.accumulo.proxy.thrift.PCompactionReason;
+import org.apache.accumulo.proxy.thrift.PCompactionType;
+import org.apache.accumulo.proxy.thrift.PIteratorScope;
+import org.apache.accumulo.proxy.thrift.PIteratorSetting;
+import org.apache.accumulo.proxy.thrift.PScanState;
+import org.apache.accumulo.proxy.thrift.PScanType;
+import org.apache.accumulo.proxy.thrift.PSystemPermission;
+import org.apache.accumulo.proxy.thrift.PTablePermission;
+import org.apache.accumulo.proxy.thrift.PTimeType;
+import org.apache.accumulo.proxy.thrift.UserPass;
+import org.apache.accumulo.server.test.functional.SlowIterator;
+import org.apache.accumulo.test.MiniAccumuloCluster;
+import org.apache.thrift.TException;
+import org.apache.thrift.server.TServer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+/**
+ * An example unit test that shows how to use MiniAccumuloCluster in a unit test
+ */
+
+public class SimpleTest {
+  
+  public static TemporaryFolder folder = new TemporaryFolder();
+  
+  private static MiniAccumuloCluster accumulo;
+  private static String secret = "superSecret";
+  private static Random random = new Random();
+  private static TServer proxyServer;
+  private static Thread thread;
+  private static int proxyPort;
+  private static org.apache.accumulo.proxy.thrift.AccumuloProxy.Client client;
+  private static UserPass creds = new UserPass("root", ByteBuffer.wrap(secret.getBytes()));
+
+  @BeforeClass
+  public static void setupMiniCluster() throws Exception {
+    folder.create();
+    accumulo = new MiniAccumuloCluster(folder.getRoot(), secret);
+    accumulo.start();
+  
+    Properties props = new Properties();
+    props.put("org.apache.accumulo.proxy.ProxyServer.instancename", accumulo.getInstanceName());
+    props.put("org.apache.accumulo.proxy.ProxyServer.zookeepers", accumulo.getZookeepers());
+    
+    proxyPort = 40000 + random.nextInt(20000);
+    proxyServer = Proxy.createProxyServer(
+        org.apache.accumulo.proxy.thrift.AccumuloProxy.class,
+        org.apache.accumulo.proxy.ProxyServer.class, 
+        proxyPort, 
+        props);
+    thread = new Thread() {
+      @Override
+      public void run() {
+        proxyServer.serve();
+      }
+    };
+    thread.start();
+    while (!proxyServer.isServing())
+      UtilWaitThread.sleep(100);
+    client = new TestProxyClient("localhost", proxyPort).proxy();
+  }
+
+  //@Test(timeout = 10000)
+  public void testPing() throws Exception {
+    client.ping(creds);
+  }
+  
+  //@Test(timeout = 10000)
+  public void testInstanceOperations() throws Exception {
+    int tservers = 0;
+    for (String tserver : client.instanceOperations_getTabletServers(creds)) {
+      client.instanceOperations_pingTabletServer(creds, tserver);
+      tservers++;
+    }
+    assertTrue(tservers > 0);
+    
+    // get something we know is in the site config
+    Map<String,String> cfg = client.instanceOperations_getSiteConfiguration(creds);
+    assertTrue(cfg.get("instance.dfs.dir").startsWith("/tmp/junit"));
+    
+    // set a property in zookeeper
+    client.instanceOperations_setProperty(creds, "table.split.threshold", "500M");
+    
+    // check that we can read it
+    cfg = client.instanceOperations_getSystemConfiguration(creds);
+    assertEquals("500M", cfg.get("table.split.threshold"));
+    
+    // unset the setting, check that it's not what it was
+    client.instanceOperations_removeProperty(creds, "table.split.threshold");
+    cfg = client.instanceOperations_getSystemConfiguration(creds);
+    assertNotEquals("500M", cfg.get("table.split.threshold"));
+    
+    // try to load some classes via the proxy
+    assertTrue(client.instanceOperations_testClassLoad(creds, DevNull.class.getName(), SortedKeyValueIterator.class.getName()));
+    assertFalse(client.instanceOperations_testClassLoad(creds, "foo.bar", SortedKeyValueIterator.class.getName()));
+
+    // create a table that's very slow, so we can look for scans/compactions
+    client.tableOperations_create(creds, "slow", true, PTimeType.MILLIS);
+    PIteratorSetting setting = new PIteratorSetting(100, "slow", SlowIterator.class.getName(), Collections.singletonMap("sleepTime", "100"));
+    client.tableOperations_attachIterator(creds, "slow", setting, EnumSet.allOf(PIteratorScope.class));
+    client.updateAndFlush(creds, "slow", mutation("row", "cf", "cq", "value"));
+    client.updateAndFlush(creds, "slow", mutation("row2", "cf", "cq", "value"));
+    client.updateAndFlush(creds, "slow", mutation("row3", "cf", "cq", "value"));
+    client.updateAndFlush(creds, "slow", mutation("row4", "cf", "cq", "value"));
+    
+    // scan
+    Thread t = new Thread() {
+      @Override
+      public void run() {
+        String scanner;
+        try {
+          Client client2 = new TestProxyClient("localhost", proxyPort).proxy();
+          scanner = client2.createScanner(creds, "slow", null, null, null);
+          client2.scanner_next_k(scanner, 10);
+          client2.close_scanner(scanner);
+        } catch (TException e) {
+          throw new RuntimeException(e);
+        }
+      }
+    };
+    t.start();
+    // look for the scan
+    List<PActiveScan> scans = Collections.emptyList();
+    loop:
+    for (int i = 0; i < 100; i++) {
+      for (String tserver: client.instanceOperations_getTabletServers(creds)) {
+       scans = client.instanceOperations_getActiveScans(creds, tserver);
+       if (!scans.isEmpty())
+         break loop;
+       UtilWaitThread.sleep(10);
+      }
+    }
+    t.join();
+    assertFalse(scans.isEmpty());
+    PActiveScan scan = scans.get(0);
+    assertEquals("root", scan.getUser());
+    assertEquals(PScanState.RUNNING, scan.getState());
+    assertEquals(PScanType.SINGLE, scan.getType());
+    assertEquals("slow", scan.getTable());
+    Map<String,String> map = client.tableOperations_tableIdMap(creds);
+    assertEquals(map.get("slow"), scan.getExtent().tableId);
+    assertTrue(scan.getExtent().endRow == null);
+    assertTrue(scan.getExtent().prevEndRow == null);
+    
+    // start a compaction
+    t = new Thread() {
+      @Override
+      public void run() {
+        try {
+          Client client2 = new TestProxyClient("localhost", proxyPort).proxy();
+          client2.tableOperations_compact(creds, "slow", null, null, null, true, true);
+        } catch (TException e) {
+          throw new RuntimeException(e);
+        }
+      }
+    };
+    t.start();
+    
+    // try to catch it in the act
+    List<PActiveCompaction> compactions = Collections.emptyList();
+    loop2:
+    for (int i = 0; i < 100; i++) {
+      for (String tserver: client.instanceOperations_getTabletServers(creds)) {
+        compactions = client.instanceOperations_getActiveCompactions(creds, tserver);
+        if (!compactions.isEmpty())
+          break loop2;
+      }
+      UtilWaitThread.sleep(10);
+    }
+    t.join();
+    // verify the compaction information
+    assertFalse(compactions.isEmpty());
+    PActiveCompaction c = compactions.get(0);
+    assertEquals(map.get("slow"), c.getExtent().tableId);
+    assertTrue(c.inputFiles.isEmpty());
+    assertEquals(PCompactionType.MINOR, c.getType());
+    assertEquals(PCompactionReason.USER, c.getReason());
+    assertEquals("", c.localityGroup);
+    assertTrue(c.outputFile.contains("default_tablet"));
+  }
+  
+  @Test
+  public void testSecurityOperations() throws Exception {
+    // check password
+    assertTrue(client.securityOperations_authenticateUser(creds, "root", s2bb(secret)));
+    assertFalse(client.securityOperations_authenticateUser(creds, "root", s2bb("")));
+
+    // create a user
+    client.securityOperations_createUser(creds, "stooge", s2bb("password"));
+    // change auths
+    Set<String> users = client.securityOperations_listUsers(creds);
+    assertEquals(new HashSet<String>(Arrays.asList("root", "stooge")), users);
+    HashSet<ByteBuffer> auths = new HashSet<ByteBuffer>(Arrays.asList(s2bb("A"),s2bb("B")));
+    client.securityOperations_changeUserAuthorizations(creds, "stooge", auths);
+    List<ByteBuffer> update = client.securityOperations_getUserAuthorizations(creds, "stooge");
+    assertEquals(auths, new HashSet<ByteBuffer>(update));
+    
+    // change password
+    client.securityOperations_changeUserPassword(creds, "stooge", s2bb(""));
+    assertTrue(client.securityOperations_authenticateUser(creds, "stooge", s2bb("")));
+    
+    // check permission failure
+    UserPass stooge = new UserPass("stooge", s2bb(""));
+    try {
+      client.tableOperations_create(stooge, "fail", true, PTimeType.MILLIS);
+      fail("should not create the table");
+    } catch (TException ex) {
+      assertFalse(client.tableOperations_list(creds).contains("fail"));
+    }
+    // grant permissions and test
+    assertFalse(client.securityOperations_hasSystemPermission(creds, "stooge", PSystemPermission.CREATE_TABLE));
+    client.securityOperations_grantSystemPermission(creds, "stooge", PSystemPermission.CREATE_TABLE);
+    assertTrue(client.securityOperations_hasSystemPermission(creds, "stooge", PSystemPermission.CREATE_TABLE));
+    client.tableOperations_create(stooge, "success", true, PTimeType.MILLIS);
+    client.tableOperations_list(creds).contains("succcess");
+    
+    // revoke permissions
+    client.securityOperations_revokeSystemPermission(creds, "stooge", PSystemPermission.CREATE_TABLE);
+    assertFalse(client.securityOperations_hasSystemPermission(creds, "stooge", PSystemPermission.CREATE_TABLE));
+    try {
+      client.tableOperations_create(stooge, "fail", true, PTimeType.MILLIS);
+      fail("should not create the table");
+    } catch (TException ex) {
+      assertFalse(client.tableOperations_list(creds).contains("fail"));
+    }
+    // create a table to test table permissions
+    client.tableOperations_create(creds, "test", true, PTimeType.MILLIS);
+    // denied!
+    try {
+      String scanner = client.createScanner(stooge, "test", null, null, null);
+      client.scanner_next_k(scanner, 100);
+      fail("stooge should not read table test");
+    } catch (TException ex) {
+    }
+    // grant
+    assertFalse(client.securityOperations_hasTablePermission(creds, "stooge", "test", PTablePermission.READ));
+    client.securityOperations_grantTablePermission(creds, "stooge", "test", PTablePermission.READ);
+    assertTrue(client.securityOperations_hasTablePermission(creds, "stooge", "test", PTablePermission.READ));
+    String scanner = client.createScanner(stooge, "test", null, null, null);
+    client.scanner_next_k(scanner, 10);
+    client.close_scanner(scanner);
+    // revoke
+    client.securityOperations_revokeTablePermission(creds, "stooge", "test", PTablePermission.READ);
+    assertFalse(client.securityOperations_hasTablePermission(creds, "stooge", "test", PTablePermission.READ));
+    try {
+      scanner = client.createScanner(stooge, "test", null, null, null);
+      client.scanner_next_k(scanner, 100);
+      fail("stooge should not read table test");
+    } catch (TException ex) {
+    }
+    
+    // delete user
+    client.securityOperations_dropUser(creds, "stooge");
+    users = client.securityOperations_listUsers(creds);
+    assertEquals(1, users.size());
+    
+  }
+  
+  private Map<ByteBuffer,List<PColumnUpdate>> mutation(String row, String cf, String cq, String value) {
+    PColumnUpdate upd = new PColumnUpdate(s2bb(cf), s2bb(cq));
+    upd.setValue(value.getBytes());
+    return Collections.singletonMap(s2bb(row), Collections.singletonList(upd));
+  }
+
+  private ByteBuffer s2bb(String cf) {
+    return ByteBuffer.wrap(cf.getBytes());
+  }
+
+  @AfterClass
+  public static void tearDownMiniCluster() throws Exception {
+    accumulo.stop();
+    folder.delete();
+  }
+  
+}

Propchange: accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/SimpleTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyInstanceOperations.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyInstanceOperations.java?rev=1437567&view=auto
==============================================================================
--- accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyInstanceOperations.java (added)
+++ accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyInstanceOperations.java Wed Jan 23 16:57:00 2013
@@ -0,0 +1,82 @@
+/*
+ * 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.accumulo.proxy;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.nio.ByteBuffer;
+import java.util.Properties;
+
+import org.apache.accumulo.proxy.Proxy;
+import org.apache.accumulo.proxy.TestProxyClient;
+import org.apache.accumulo.proxy.thrift.UserPass;
+import org.apache.thrift.TException;
+import org.apache.thrift.server.TServer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class TestProxyInstanceOperations {
+  protected static TServer proxy;
+  protected static Thread thread;
+  protected static TestProxyClient tpc;
+  protected static UserPass userpass;
+  protected static final int port = 10197;
+  
+  @BeforeClass
+  public static void setup() throws Exception {
+    Properties prop = new Properties();
+    prop.setProperty("org.apache.accumulo.proxy.ProxyServer.useMockInstance", "true");
+    
+    proxy = Proxy.createProxyServer(Class.forName("org.apache.accumulo.proxy.thrift.AccumuloProxy"),
+        Class.forName("org.apache.accumulo.proxy.ProxyServer"), port, prop);
+    thread = new Thread() {
+      @Override
+      public void run() {
+        proxy.serve();
+      }
+    };
+    thread.start();
+    tpc = new TestProxyClient("localhost", port);
+    userpass = new UserPass("root", ByteBuffer.wrap("".getBytes()));
+  }
+  
+  @AfterClass
+  public static void tearDown() throws InterruptedException {
+    proxy.stop();
+    thread.join();
+  }
+  
+  @Test
+  public void properties() throws TException {
+    tpc.proxy().instanceOperations_setProperty(userpass, "test.systemprop", "whistletips");
+    
+    assertEquals(tpc.proxy().instanceOperations_getSystemConfiguration(userpass).get("test.systemprop"), "whistletips");
+    tpc.proxy().instanceOperations_removeProperty(userpass, "test.systemprop");
+    assertNull(tpc.proxy().instanceOperations_getSystemConfiguration(userpass).get("test.systemprop"));
+    
+  }
+  
+  @Test
+  public void testClassLoad() throws TException {
+    assertTrue(tpc.proxy().instanceOperations_testClassLoad(userpass, "org.apache.accumulo.core.iterators.user.RegExFilter",
+        "org.apache.accumulo.core.iterators.Filter"));
+  }
+  
+}

Propchange: accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyInstanceOperations.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyReadWrite.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyReadWrite.java?rev=1437567&view=auto
==============================================================================
--- accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyReadWrite.java (added)
+++ accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyReadWrite.java Wed Jan 23 16:57:00 2013
@@ -0,0 +1,391 @@
+/*
+ * 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.accumulo.proxy;
+
+import static org.junit.Assert.assertEquals;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+import org.apache.accumulo.core.client.IteratorSetting;
+import org.apache.accumulo.core.iterators.user.RegExFilter;
+import org.apache.accumulo.proxy.Proxy;
+import org.apache.accumulo.proxy.TestProxyClient;
+import org.apache.accumulo.proxy.Util;
+import org.apache.accumulo.proxy.thrift.PColumnUpdate;
+import org.apache.accumulo.proxy.thrift.PIteratorSetting;
+import org.apache.accumulo.proxy.thrift.PKey;
+import org.apache.accumulo.proxy.thrift.PKeyValue;
+import org.apache.accumulo.proxy.thrift.PRange;
+import org.apache.accumulo.proxy.thrift.PScanResult;
+import org.apache.accumulo.proxy.thrift.PTimeType;
+import org.apache.accumulo.proxy.thrift.UserPass;
+import org.apache.thrift.server.TServer;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class TestProxyReadWrite {
+  protected static TServer proxy;
+  protected static Thread thread;
+  protected static TestProxyClient tpc;
+  protected static UserPass userpass;
+  protected static final int port = 10194;
+  protected static final String testtable = "testtable";
+  
+  @BeforeClass
+  public static void setup() throws Exception {
+    Properties prop = new Properties();
+    prop.setProperty("org.apache.accumulo.proxy.ProxyServer.useMockInstance", "true");
+    
+    proxy = Proxy.createProxyServer(Class.forName("org.apache.accumulo.proxy.thrift.AccumuloProxy"),
+        Class.forName("org.apache.accumulo.proxy.ProxyServer"), port, prop);
+    thread = new Thread() {
+      @Override
+      public void run() {
+        proxy.serve();
+      }
+    };
+    thread.start();
+    tpc = new TestProxyClient("localhost", port);
+    userpass = new UserPass("root", ByteBuffer.wrap("".getBytes()));
+  }
+  
+  @AfterClass
+  public static void tearDown() throws InterruptedException {
+    proxy.stop();
+    thread.join();
+  }
+  
+  @Before
+  public void makeTestTable() throws Exception {
+    tpc.proxy().tableOperations_create(userpass, testtable, true, PTimeType.MILLIS);
+  }
+  
+  @After
+  public void deleteTestTable() throws Exception {
+    tpc.proxy().tableOperations_delete(userpass, testtable);
+  }
+  
+  private static void addMutation(Map<ByteBuffer,List<PColumnUpdate>> mutations, String row, String cf, String cq, String value) {
+    PColumnUpdate update = new PColumnUpdate(ByteBuffer.wrap(cf.getBytes()), ByteBuffer.wrap(cq.getBytes()));
+    update.setValue(value.getBytes());
+    mutations.put(ByteBuffer.wrap(row.getBytes()), Collections.singletonList(update));
+  }
+  
+  private static void addMutation(Map<ByteBuffer,List<PColumnUpdate>> mutations, String row, String cf, String cq, String vis, String value) {
+    PColumnUpdate update = new PColumnUpdate(ByteBuffer.wrap(cf.getBytes()), ByteBuffer.wrap(cq.getBytes()));
+    update.setValue(value.getBytes());
+    update.setColVisibility(vis.getBytes());
+    mutations.put(ByteBuffer.wrap(row.getBytes()), Collections.singletonList(update));
+  }
+  
+  /**
+   * Insert 100000 cells which have as the row [0..99999] (padded with zeros). Set a range so only the entries between -Inf...5 come back (there should be
+   * 50,000)
+   * 
+   * @throws Exception
+   */
+  @Test
+  public void readWriteBatchOneShotWithRange() throws Exception {
+    int maxInserts = 100000;
+    Map<ByteBuffer,List<PColumnUpdate>> mutations = new HashMap<ByteBuffer,List<PColumnUpdate>>();
+    String format = "%1$05d";
+    for (int i = 0; i < maxInserts; i++) {
+      addMutation(mutations, String.format(format, i), "cf" + i, "cq" + i, Util.randString(10));
+      
+      if (i % 1000 == 0 || i == maxInserts - 1) {
+        tpc.proxy().updateAndFlush(userpass, testtable, mutations);
+        mutations.clear();
+      }
+    }
+    
+    PKey stop = new PKey();
+    stop.setRow("5".getBytes());
+    List<PRange> pranges = new ArrayList<PRange>();
+    pranges.add(new PRange(null, false, stop, false));
+    String cookie = tpc.proxy().createBatchScanner(userpass, testtable, null, null, pranges);
+    
+    int i = 0;
+    boolean hasNext = true;
+    
+    int k = 1000;
+    while (hasNext) {
+      PScanResult kvList = tpc.proxy().scanner_next_k(cookie, k);
+      i += kvList.getResultsSize();
+      hasNext = kvList.isMore();
+    }
+    assertEquals(i, 50000);
+  }
+  
+  /**
+   * Insert 100000 cells which have as the row [0..99999] (padded with zeros). Filter the results so only the even numbers come back.
+   * 
+   * @throws Exception
+   */
+  @Test
+  public void readWriteBatchOneShotWithFilterIterator() throws Exception {
+    int maxInserts = 10000;
+    Map<ByteBuffer,List<PColumnUpdate>> mutations = new HashMap<ByteBuffer,List<PColumnUpdate>>();
+    String format = "%1$05d";
+    for (int i = 0; i < maxInserts; i++) {
+      addMutation(mutations, String.format(format, i), "cf" + i, "cq" + i, Util.randString(10));
+      
+      if (i % 1000 == 0 || i == maxInserts - 1) {
+        tpc.proxy().updateAndFlush(userpass, testtable, mutations);
+        mutations.clear();
+      }
+      
+    }
+    
+    String regex = ".*[02468]";
+    
+    IteratorSetting is = new IteratorSetting(50, regex, RegExFilter.class);
+    RegExFilter.setRegexs(is, regex, null, null, null, false);
+    
+    PIteratorSetting pis = Util.iteratorSetting2ProxyIteratorSetting(is);
+    String cookie = tpc.proxy().createBatchScanner(userpass, testtable, null, Collections.singletonList(pis), null);
+    
+    int i = 0;
+    boolean hasNext = true;
+    
+    int k = 1000;
+    while (hasNext) {
+      PScanResult kvList = tpc.proxy().scanner_next_k(cookie, k);
+      for (PKeyValue kv : kvList.getResults()) {
+        assertEquals(Integer.parseInt(new String(kv.getKey().getRow())), i);
+        
+        i += 2;
+      }
+      hasNext = kvList.isMore();
+    }
+  }
+  
+  @Test
+  public void readWriteOneShotWithRange() throws Exception {
+    int maxInserts = 100000;
+    Map<ByteBuffer,List<PColumnUpdate>> mutations = new HashMap<ByteBuffer,List<PColumnUpdate>>();
+    String format = "%1$05d";
+    for (int i = 0; i < maxInserts; i++) {
+      addMutation(mutations, String.format(format, i), "cf" + i, "cq" + i, Util.randString(10));
+      
+      if (i % 1000 == 0 || i == maxInserts - 1) {
+        tpc.proxy().updateAndFlush(userpass, testtable, mutations);
+        mutations.clear();
+      }
+    }
+    
+    PKey stop = new PKey();
+    stop.setRow("5".getBytes());
+    String cookie = tpc.proxy().createScanner(userpass, testtable, null, null, new PRange(null, false, stop, false));
+    
+    int i = 0;
+    boolean hasNext = true;
+    
+    int k = 1000;
+    while (hasNext) {
+      PScanResult kvList = tpc.proxy().scanner_next_k(cookie, k);
+      i += kvList.getResultsSize();
+      hasNext = kvList.isMore();
+    }
+    assertEquals(i, 50000);
+  }
+  
+  /**
+   * Insert 100000 cells which have as the row [0..99999] (padded with zeros). Filter the results so only the even numbers come back.
+   * 
+   * @throws Exception
+   */
+  @Test
+  public void readWriteOneShotWithFilterIterator() throws Exception {
+    int maxInserts = 10000;
+    Map<ByteBuffer,List<PColumnUpdate>> mutations = new HashMap<ByteBuffer,List<PColumnUpdate>>();
+    String format = "%1$05d";
+    for (int i = 0; i < maxInserts; i++) {
+      addMutation(mutations, String.format(format, i), "cf" + i, "cq" + i, Util.randString(10));
+      
+      if (i % 1000 == 0 || i == maxInserts - 1) {
+        
+        tpc.proxy().updateAndFlush(userpass, testtable, mutations);
+        mutations.clear();
+        
+      }
+      
+    }
+    
+    String regex = ".*[02468]";
+    
+    IteratorSetting is = new IteratorSetting(50, regex, RegExFilter.class);
+    RegExFilter.setRegexs(is, regex, null, null, null, false);
+    
+    PIteratorSetting pis = Util.iteratorSetting2ProxyIteratorSetting(is);
+    String cookie = tpc.proxy().createScanner(userpass, testtable, null, Collections.singletonList(pis), null);
+    
+    int i = 0;
+    boolean hasNext = true;
+    
+    int k = 1000;
+    while (hasNext) {
+      PScanResult kvList = tpc.proxy().scanner_next_k(cookie, k);
+      for (PKeyValue kv : kvList.getResults()) {
+        assertEquals(Integer.parseInt(new String(kv.getKey().getRow())), i);
+        
+        i += 2;
+      }
+      hasNext = kvList.isMore();
+    }
+  }
+  
+  // @Test
+  // This test takes kind of a long time. Enable it if you think you may have memory issues.
+  public void manyWritesAndReads() throws Exception {
+    int maxInserts = 1000000;
+    Map<ByteBuffer,List<PColumnUpdate>> mutations = new HashMap<ByteBuffer,List<PColumnUpdate>>();
+    String format = "%1$06d";
+    String writer = tpc.proxy().createWriter(userpass, testtable);
+    for (int i = 0; i < maxInserts; i++) {
+      addMutation(mutations, String.format(format, i), "cf" + i, "cq" + i, Util.randString(10));
+      
+      if (i % 1000 == 0 || i == maxInserts - 1) {
+        
+        tpc.proxy().writer_update(writer, mutations);
+        mutations.clear();
+        
+      }
+      
+    }
+    
+    tpc.proxy().writer_flush(writer);
+    tpc.proxy().writer_close(writer);
+    
+    String cookie = tpc.proxy().createBatchScanner(userpass, testtable, null, null, null);
+    
+    int i = 0;
+    boolean hasNext = true;
+    
+    int k = 1000;
+    while (hasNext) {
+      PScanResult kvList = tpc.proxy().scanner_next_k(cookie, k);
+      for (PKeyValue kv : kvList.getResults()) {
+        assertEquals(Integer.parseInt(new String(kv.getKey().getRow())), i);
+        i++;
+      }
+      hasNext = kvList.isMore();
+      if (hasNext)
+        assertEquals(k, kvList.getResults().size());
+    }
+    assertEquals(maxInserts, i);
+  }
+  
+  @Test
+  public void asynchReadWrite() throws Exception {
+    int maxInserts = 10000;
+    Map<ByteBuffer,List<PColumnUpdate>> mutations = new HashMap<ByteBuffer,List<PColumnUpdate>>();
+    String format = "%1$05d";
+    String writer = tpc.proxy().createWriter(userpass, testtable);
+    for (int i = 0; i < maxInserts; i++) {
+      addMutation(mutations, String.format(format, i), "cf" + i, "cq" + i, Util.randString(10));
+      
+      if (i % 1000 == 0 || i == maxInserts - 1) {
+        tpc.proxy().writer_update(writer, mutations);
+        mutations.clear();
+      }
+    }
+    
+    tpc.proxy().writer_flush(writer);
+    tpc.proxy().writer_close(writer);
+    
+    String regex = ".*[02468]";
+    
+    IteratorSetting is = new IteratorSetting(50, regex, RegExFilter.class);
+    RegExFilter.setRegexs(is, regex, null, null, null, false);
+    
+    PIteratorSetting pis = Util.iteratorSetting2ProxyIteratorSetting(is);
+    String cookie = tpc.proxy().createBatchScanner(userpass, testtable, null, Collections.singletonList(pis), null);
+    
+    int i = 0;
+    boolean hasNext = true;
+    
+    int k = 1000;
+    int numRead = 0;
+    while (hasNext) {
+      PScanResult kvList = tpc.proxy().scanner_next_k(cookie, k);
+      for (PKeyValue kv : kvList.getResults()) {
+        assertEquals(i, Integer.parseInt(new String(kv.getKey().getRow())));
+        numRead++;
+        i += 2;
+      }
+      hasNext = kvList.isMore();
+    }
+    assertEquals(maxInserts / 2, numRead);
+  }
+  
+  @Test
+  public void testVisibility() throws Exception {
+    
+    Set<ByteBuffer> auths = new HashSet<ByteBuffer>();
+    auths.add(ByteBuffer.wrap("even".getBytes()));
+    tpc.proxy().securityOperations_changeUserAuthorizations(userpass, "root", auths);
+    
+    int maxInserts = 10000;
+    Map<ByteBuffer,List<PColumnUpdate>> mutations = new HashMap<ByteBuffer,List<PColumnUpdate>>();
+    String format = "%1$05d";
+    String writer = tpc.proxy().createWriter(userpass, testtable);
+    for (int i = 0; i < maxInserts; i++) {
+      if (i % 2 == 0)
+        addMutation(mutations, String.format(format, i), "cf" + i, "cq" + i, "even", Util.randString(10));
+      else
+        addMutation(mutations, String.format(format, i), "cf" + i, "cq" + i, "odd", Util.randString(10));
+      
+      if (i % 1000 == 0 || i == maxInserts - 1) {
+        tpc.proxy().writer_update(writer, mutations);
+        mutations.clear();
+      }
+    }
+    
+    tpc.proxy().writer_flush(writer);
+    tpc.proxy().writer_close(writer);
+    String cookie = tpc.proxy().createBatchScanner(userpass, testtable, auths, null, null);
+    
+    int i = 0;
+    boolean hasNext = true;
+    
+    int k = 1000;
+    int numRead = 0;
+    while (hasNext) {
+      PScanResult kvList = tpc.proxy().scanner_next_k(cookie, k);
+      for (PKeyValue kv : kvList.getResults()) {
+        assertEquals(Integer.parseInt(new String(kv.getKey().getRow())), i);
+        i += 2;
+        numRead++;
+      }
+      hasNext = kvList.isMore();
+      
+    }
+    assertEquals(maxInserts / 2, numRead);
+  }
+  
+}

Propchange: accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyReadWrite.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxySecurityOperations.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxySecurityOperations.java?rev=1437567&view=auto
==============================================================================
--- accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxySecurityOperations.java (added)
+++ accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxySecurityOperations.java Wed Jan 23 16:57:00 2013
@@ -0,0 +1,142 @@
+/*
+ * 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.accumulo.proxy;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.nio.ByteBuffer;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Properties;
+
+import org.apache.accumulo.proxy.Proxy;
+import org.apache.accumulo.proxy.TestProxyClient;
+import org.apache.accumulo.proxy.thrift.PSystemPermission;
+import org.apache.accumulo.proxy.thrift.PTablePermission;
+import org.apache.accumulo.proxy.thrift.PTimeType;
+import org.apache.accumulo.proxy.thrift.UserPass;
+import org.apache.thrift.TException;
+import org.apache.thrift.server.TServer;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class TestProxySecurityOperations {
+  protected static TServer proxy;
+  protected static Thread thread;
+  protected static TestProxyClient tpc;
+  protected static UserPass userpass;
+  protected static final int port = 10196;
+  protected static final String testtable = "testtable";
+  protected static final String testuser = "VonJines";
+  protected static final ByteBuffer testpw = ByteBuffer.wrap("fiveones".getBytes());
+  
+  @BeforeClass
+  public static void setup() throws Exception {
+    Properties prop = new Properties();
+    prop.setProperty("org.apache.accumulo.proxy.ProxyServer.useMockInstance", "true");
+    
+    proxy = Proxy.createProxyServer(Class.forName("org.apache.accumulo.proxy.thrift.AccumuloProxy"),
+        Class.forName("org.apache.accumulo.proxy.ProxyServer"), port, prop);
+    thread = new Thread() {
+      @Override
+      public void run() {
+        proxy.serve();
+      }
+    };
+    thread.start();
+    
+    tpc = new TestProxyClient("localhost", port);
+    userpass = new UserPass("root", ByteBuffer.wrap("".getBytes()));
+  }
+  
+  @AfterClass
+  public static void tearDown() throws InterruptedException {
+    proxy.stop();
+    thread.join();
+  }
+  
+  @Before
+  public void makeTestTableAndUser() throws Exception {
+    tpc.proxy().tableOperations_create(userpass, testtable, true, PTimeType.MILLIS);
+    tpc.proxy().securityOperations_createUser(userpass, testuser, testpw);
+  }
+  
+  @After
+  public void deleteTestTable() throws Exception {
+    tpc.proxy().tableOperations_delete(userpass, testtable);
+    tpc.proxy().securityOperations_dropUser(userpass, testuser);
+  }
+  
+  @Test
+  public void create() throws TException {
+    tpc.proxy().securityOperations_createUser(userpass, testuser + "2", testpw);
+    assertTrue(tpc.proxy().securityOperations_listUsers(userpass).contains(testuser + "2"));
+    tpc.proxy().securityOperations_dropUser(userpass, testuser + "2");
+    assertTrue(!tpc.proxy().securityOperations_listUsers(userpass).contains(testuser + "2"));
+  }
+  
+  @Test
+  public void authenticate() throws TException {
+    assertTrue(tpc.proxy().securityOperations_authenticateUser(userpass, testuser, testpw));
+    assertFalse(tpc.proxy().securityOperations_authenticateUser(userpass, "EvilUser", testpw));
+    
+    tpc.proxy().securityOperations_changeUserPassword(userpass, testuser, ByteBuffer.wrap("newpass".getBytes()));
+    assertFalse(tpc.proxy().securityOperations_authenticateUser(userpass, testuser, testpw));
+    assertTrue(tpc.proxy().securityOperations_authenticateUser(userpass, testuser, ByteBuffer.wrap("newpass".getBytes())));
+    
+  }
+  
+  @Test
+  public void tablePermissions() throws TException {
+    tpc.proxy().securityOperations_grantTablePermission(userpass, testuser, testtable, PTablePermission.ALTER_TABLE);
+    assertTrue(tpc.proxy().securityOperations_hasTablePermission(userpass, testuser, testtable, PTablePermission.ALTER_TABLE));
+    
+    tpc.proxy().securityOperations_revokeTablePermission(userpass, testuser, testtable, PTablePermission.ALTER_TABLE);
+    assertFalse(tpc.proxy().securityOperations_hasTablePermission(userpass, testuser, testtable, PTablePermission.ALTER_TABLE));
+    
+  }
+  
+  @Test
+  public void systemPermissions() throws TException {
+    tpc.proxy().securityOperations_grantSystemPermission(userpass, testuser, PSystemPermission.ALTER_USER);
+    assertTrue(tpc.proxy().securityOperations_hasSystemPermission(userpass, testuser, PSystemPermission.ALTER_USER));
+    
+    tpc.proxy().securityOperations_revokeSystemPermission(userpass, testuser, PSystemPermission.ALTER_USER);
+    assertFalse(tpc.proxy().securityOperations_hasSystemPermission(userpass, testuser, PSystemPermission.ALTER_USER));
+    
+  }
+  
+  @Test
+  public void auths() throws TException {
+    HashSet<ByteBuffer> newauths = new HashSet<ByteBuffer>();
+    newauths.add(ByteBuffer.wrap("BBR".getBytes()));
+    newauths.add(ByteBuffer.wrap("Barney".getBytes()));
+    tpc.proxy().securityOperations_changeUserAuthorizations(userpass, testuser, newauths);
+    List<ByteBuffer> actualauths = tpc.proxy().securityOperations_getUserAuthorizations(userpass, testuser);
+    assertEquals(actualauths.size(), newauths.size());
+    
+    for (ByteBuffer auth : actualauths) {
+      assertTrue(newauths.contains(auth));
+    }
+  }
+  
+}

Propchange: accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxySecurityOperations.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyTableOperations.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyTableOperations.java?rev=1437567&view=auto
==============================================================================
--- accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyTableOperations.java (added)
+++ accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyTableOperations.java Wed Jan 23 16:57:00 2013
@@ -0,0 +1,216 @@
+/*
+ * 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.accumulo.proxy;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.nio.ByteBuffer;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+import org.apache.accumulo.proxy.Proxy;
+import org.apache.accumulo.proxy.TestProxyClient;
+import org.apache.accumulo.proxy.thrift.PColumnUpdate;
+import org.apache.accumulo.proxy.thrift.PTimeType;
+import org.apache.accumulo.proxy.thrift.UserPass;
+import org.apache.thrift.TException;
+import org.apache.thrift.server.TServer;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class TestProxyTableOperations {
+  
+  protected static TServer proxy;
+  protected static Thread thread;
+  protected static TestProxyClient tpc;
+  protected static UserPass userpass;
+  protected static final int port = 10195;
+  protected static final String testtable = "testtable";
+  
+  @BeforeClass
+  public static void setup() throws Exception {
+    Properties prop = new Properties();
+    prop.setProperty("org.apache.accumulo.proxy.ProxyServer.useMockInstance", "true");
+    
+    proxy = Proxy.createProxyServer(Class.forName("org.apache.accumulo.proxy.thrift.AccumuloProxy"),
+        Class.forName("org.apache.accumulo.proxy.ProxyServer"), port, prop);
+    thread = new Thread() {
+      @Override
+      public void run() {
+        proxy.serve();
+      }
+    };
+    thread.start();
+    tpc = new TestProxyClient("localhost", port);
+    userpass = new UserPass("root", ByteBuffer.wrap("".getBytes()));
+  }
+  
+  @AfterClass
+  public static void tearDown() throws InterruptedException {
+    proxy.stop();
+    thread.join();
+  }
+  
+  @Before
+  public void makeTestTable() throws Exception {
+    tpc.proxy().tableOperations_create(userpass, testtable, true, PTimeType.MILLIS);
+  }
+  
+  @After
+  public void deleteTestTable() throws Exception {
+    tpc.proxy().tableOperations_delete(userpass, testtable);
+  }
+  
+  @Test
+  public void ping() throws Exception {
+    tpc.proxy().ping(userpass);
+  }
+  
+  @Test
+  public void createExistsDelete() throws TException {
+    assertFalse(tpc.proxy().tableOperations_exists(userpass, "testtable2"));
+    tpc.proxy().tableOperations_create(userpass, "testtable2", true, PTimeType.MILLIS);
+    assertTrue(tpc.proxy().tableOperations_exists(userpass, "testtable2"));
+    tpc.proxy().tableOperations_delete(userpass, "testtable2");
+    assertFalse(tpc.proxy().tableOperations_exists(userpass, "testtable2"));
+  }
+  
+  @Test
+  public void listRename() throws TException {
+    assertFalse(tpc.proxy().tableOperations_exists(userpass, "testtable2"));
+    tpc.proxy().tableOperations_rename(userpass, testtable, "testtable2");
+    assertTrue(tpc.proxy().tableOperations_exists(userpass, "testtable2"));
+    tpc.proxy().tableOperations_rename(userpass, "testtable2", testtable);
+    assertTrue(tpc.proxy().tableOperations_list(userpass).contains("testtable"));
+    
+  }
+  
+  // This test does not yet function because the backing Mock instance does not yet support merging
+  // TODO: add back in as a test when Mock is improved
+  // @Test
+  public void merge() throws TException {
+    Set<ByteBuffer> splits = new HashSet<ByteBuffer>();
+    splits.add(ByteBuffer.wrap("a".getBytes()));
+    splits.add(ByteBuffer.wrap("c".getBytes()));
+    splits.add(ByteBuffer.wrap("z".getBytes()));
+    tpc.proxy().tableOperations_addSplits(userpass, testtable, splits);
+    
+    tpc.proxy().tableOperations_merge(userpass, testtable, ByteBuffer.wrap("b".getBytes()), ByteBuffer.wrap("d".getBytes()));
+    
+    splits.remove("c");
+    
+    List<ByteBuffer> tableSplits = tpc.proxy().tableOperations_getSplits(userpass, testtable, 10);
+    
+    for (ByteBuffer split : tableSplits)
+      assertTrue(splits.contains(split));
+    assertTrue(tableSplits.size() == splits.size());
+    
+  }
+  
+  @Test
+  public void splits() throws TException {
+    Set<ByteBuffer> splits = new HashSet<ByteBuffer>();
+    splits.add(ByteBuffer.wrap("a".getBytes()));
+    splits.add(ByteBuffer.wrap("b".getBytes()));
+    splits.add(ByteBuffer.wrap("z".getBytes()));
+    tpc.proxy().tableOperations_addSplits(userpass, testtable, splits);
+    
+    List<ByteBuffer> tableSplits = tpc.proxy().tableOperations_getSplits(userpass, testtable, 10);
+    
+    for (ByteBuffer split : tableSplits)
+      assertTrue(splits.contains(split));
+    assertTrue(tableSplits.size() == splits.size());
+  }
+  
+  @Test
+  public void constraints() throws TException {
+    int cid = tpc.proxy().tableOperations_addConstraint(userpass, testtable, "org.apache.accumulo.TestConstraint");
+    Map<String,Integer> constraints = tpc.proxy().tableOperations_listConstraints(userpass, testtable);
+    assertEquals((int) constraints.get("org.apache.accumulo.TestConstraint"), cid);
+    tpc.proxy().tableOperations_removeConstraint(userpass, testtable, cid);
+    constraints = tpc.proxy().tableOperations_listConstraints(userpass, testtable);
+    assertNull(constraints.get("org.apache.accumulo.TestConstraint"));
+  }
+  
+  // This test does not yet function because the backing Mock instance does not yet support locality groups
+  // TODO: add back in as a test when Mock is improved
+  // @Test
+  public void localityGroups() throws TException {
+    Map<String,Set<String>> groups = new HashMap<String,Set<String>>();
+    Set<String> group1 = new HashSet<String>();
+    group1.add("cf1");
+    groups.put("group1", group1);
+    Set<String> group2 = new HashSet<String>();
+    group2.add("cf2");
+    group2.add("cf3");
+    groups.put("group2", group2);
+    tpc.proxy().tableOperations_setLocalityGroups(userpass, testtable, groups);
+    
+    Map<String,Set<String>> actualGroups = tpc.proxy().tableOperations_getLocalityGroups(userpass, testtable);
+    
+    assertEquals(groups.size(), actualGroups.size());
+    for (String groupName : groups.keySet()) {
+      assertTrue(actualGroups.containsKey(groupName));
+      assertEquals(groups.get(groupName).size(), actualGroups.get(groupName).size());
+      for (String cf : groups.get(groupName)) {
+        assertTrue(actualGroups.get(groupName).contains(cf));
+      }
+    }
+  }
+  
+  @Test
+  public void tableProperties() throws TException {
+    tpc.proxy().tableOperations_setProperty(userpass, testtable, "test.property1", "wharrrgarbl");
+    assertEquals(tpc.proxy().tableOperations_getProperties(userpass, testtable).get("test.property1"), "wharrrgarbl");
+    tpc.proxy().tableOperations_removeProperty(userpass, testtable, "test.property1");
+    assertNull(tpc.proxy().tableOperations_getProperties(userpass, testtable).get("test.property1"));
+  }
+  
+  private static void addMutation(Map<ByteBuffer,List<PColumnUpdate>> mutations, String row, String cf, String cq, String value) {
+    PColumnUpdate update = new PColumnUpdate(ByteBuffer.wrap(cf.getBytes()), ByteBuffer.wrap(cq.getBytes()));
+    update.setValue(value.getBytes());
+    mutations.put(ByteBuffer.wrap(row.getBytes()), Collections.singletonList(update));
+  }
+  
+  @Test
+  public void tableOperationsRowMethods() throws TException {
+    List<ByteBuffer> auths = tpc.proxy().securityOperations_getUserAuthorizations(userpass, "root");
+    // System.out.println(auths);
+    Map<ByteBuffer,List<PColumnUpdate>> mutations = new HashMap<ByteBuffer,List<PColumnUpdate>>();
+    for (int i = 0; i < 10; i++) {
+      addMutation(mutations, "" + i, "cf", "cq", "");
+    }
+    tpc.proxy().updateAndFlush(userpass, testtable, mutations);
+    
+    assertEquals(tpc.proxy().tableOperations_getMaxRow(userpass, testtable, auths, null, true, null, true), ByteBuffer.wrap("9".getBytes()));
+    
+    tpc.proxy().tableOperations_deleteRows(userpass,testtable,ByteBuffer.wrap("51".getBytes()), ByteBuffer.wrap("99".getBytes()));
+    assertEquals(tpc.proxy().tableOperations_getMaxRow(userpass, testtable, auths, null, true, null, true), ByteBuffer.wrap("5".getBytes()));
+  }
+  
+}

Propchange: accumulo/trunk/proxy/src/test/java/org/apache/accumulo/proxy/TestProxyTableOperations.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message